From fb1040fb2c68849a8aed1c5a986aa4374133b10d Mon Sep 17 00:00:00 2001 From: Pedro Pinto Date: Tue, 12 Jan 2021 11:10:39 -0500 Subject: [PATCH] Cleaned up generation of mdp3 files. --- .../sparkd/cmds/spartan/docs/cme_notes.org | 2 + .../gen/cert/templates_FixBinary.xml | 955 ++ .../cmds/spartan/market_data/gen/generate.sh | 42 + .../gen/nrcert/templates_FixBinary.xml | 955 ++ .../gen/prod/templates_FixBinary.xml | 955 ++ .../market_data/gen/sbe-all-1.20.4.jar | Bin 0 -> 731051 bytes .../market_data/gen/src/AdminHeartbeat12.h | 460 +- .../market_data/gen/src/AdminLogin15.h | 564 +- .../market_data/gen/src/AdminLogout16.h | 783 +- .../market_data/gen/src/AggressorSide.h | 167 +- .../market_data/gen/src/ChannelReset4.h | 1560 +- .../spartan/market_data/gen/src/Decimal9.h | 438 +- .../market_data/gen/src/Decimal9NULL.h | 438 +- .../spartan/market_data/gen/src/DecimalQty.h | 438 +- .../spartan/market_data/gen/src/EventType.h | 159 +- .../cmds/spartan/market_data/gen/src/FLOAT.h | 438 +- .../spartan/market_data/gen/src/GroupSize.h | 459 +- .../market_data/gen/src/GroupSize8Byte.h | 460 +- .../spartan/market_data/gen/src/HaltReason.h | 199 +- .../market_data/gen/src/InstAttribValue.h | 1894 +-- .../spartan/market_data/gen/src/LegSide.h | 159 +- .../spartan/market_data/gen/src/MDEntryType.h | 279 +- .../market_data/gen/src/MDEntryTypeBook.h | 184 +- .../gen/src/MDEntryTypeDailyStatistics.h | 178 +- .../gen/src/MDEntryTypeStatistics.h | 185 +- .../gen/src/MDIncrementalRefreshBook32.h | 3225 ++-- .../gen/src/MDIncrementalRefreshBook46.h | 3225 ++-- .../MDIncrementalRefreshDailyStatistics33.h | 2077 +-- .../MDIncrementalRefreshDailyStatistics49.h | 2077 +-- .../src/MDIncrementalRefreshLimitsBanding34.h | 2010 +-- .../src/MDIncrementalRefreshLimitsBanding50.h | 2010 +-- .../gen/src/MDIncrementalRefreshOrderBook43.h | 1981 +-- .../gen/src/MDIncrementalRefreshOrderBook47.h | 1981 +-- .../MDIncrementalRefreshSessionStatistics35.h | 1945 +-- .../MDIncrementalRefreshSessionStatistics51.h | 1936 +-- .../src/MDIncrementalRefreshTradeSummary42.h | 3026 ++-- .../src/MDIncrementalRefreshTradeSummary48.h | 3019 ++-- .../gen/src/MDIncrementalRefreshVolume37.h | 1846 +-- .../gen/src/MDInstrumentDefinitionFuture27.h | 9880 ++++++------ .../gen/src/MDInstrumentDefinitionFuture54.h | 9866 ++++++------ .../gen/src/MDInstrumentDefinitionOption41.h | 12424 ++++++++-------- .../gen/src/MDInstrumentDefinitionOption55.h | 12417 +++++++-------- .../gen/src/MDInstrumentDefinitionSpread29.h | 10674 ++++++------- .../gen/src/MDInstrumentDefinitionSpread56.h | 10667 ++++++------- .../market_data/gen/src/MDUpdateAction.h | 191 +- .../market_data/gen/src/MatchEventIndicator.h | 768 +- .../market_data/gen/src/MaturityMonthYear.h | 662 +- .../market_data/gen/src/MessageHeader.h | 661 +- .../market_data/gen/src/OpenCloseSettlFlag.h | 161 +- .../market_data/gen/src/OrderUpdateAction.h | 169 +- .../cmds/spartan/market_data/gen/src/PRICE.h | 438 +- .../cmds/spartan/market_data/gen/src/PRICE9.h | 438 +- .../spartan/market_data/gen/src/PRICENULL.h | 438 +- .../spartan/market_data/gen/src/PRICENULL9.h | 438 +- .../spartan/market_data/gen/src/PutOrCall.h | 159 +- .../market_data/gen/src/QuoteRequest39.h | 2354 +-- .../market_data/gen/src/SecurityStatus30.h | 1760 ++- .../gen/src/SecurityTradingEvent.h | 185 +- .../gen/src/SecurityTradingStatus.h | 233 +- .../gen/src/SecurityUpdateAction.h | 169 +- .../market_data/gen/src/SettlPriceType.h | 655 +- .../gen/src/SnapshotFullRefresh38.h | 2958 ++-- .../gen/src/SnapshotFullRefresh52.h | 2958 ++-- .../gen/src/SnapshotFullRefreshOrderBook44.h | 2174 +-- .../gen/src/SnapshotFullRefreshOrderBook53.h | 2174 +-- .../spartan/order_execution/gen/generate.sh | 38 +- .../order_execution/gen/src/AvgPxInd.h | 6 +- .../order_execution/gen/src/BooleanFlag.h | 6 +- .../order_execution/gen/src/BooleanNULL.h | 6 +- .../gen/src/BusinessReject521.h | 6 +- .../gen/src/ClearingAcctType.h | 6 +- .../order_execution/gen/src/CmtaGiveUpCD.h | 6 +- .../gen/src/CustOrdHandlInst.h | 6 +- .../gen/src/CustOrderCapacity.h | 6 +- .../spartan/order_execution/gen/src/DATA.h | 6 +- .../order_execution/gen/src/DKReason.h | 6 +- .../order_execution/gen/src/Decimal32NULL.h | 6 +- .../order_execution/gen/src/Decimal64NULL.h | 6 +- .../order_execution/gen/src/Establish503.h | 6 +- .../gen/src/EstablishmentAck504.h | 6 +- .../gen/src/EstablishmentReject505.h | 6 +- .../order_execution/gen/src/ExecAckStatus.h | 6 +- .../order_execution/gen/src/ExecInst.h | 6 +- .../order_execution/gen/src/ExecMode.h | 6 +- .../order_execution/gen/src/ExecReason.h | 6 +- .../order_execution/gen/src/ExecTypTrdCxl.h | 6 +- .../order_execution/gen/src/ExecutionAck539.h | 6 +- .../gen/src/ExecutionReportCancel534.h | 6 +- .../gen/src/ExecutionReportElimination524.h | 6 +- .../gen/src/ExecutionReportModify531.h | 6 +- .../gen/src/ExecutionReportNew522.h | 6 +- .../gen/src/ExecutionReportReject523.h | 6 +- .../gen/src/ExecutionReportStatus532.h | 6 +- .../ExecutionReportTradeAddendumOutright548.h | 6 +- .../ExecutionReportTradeAddendumSpread549.h | 6 +- ...ExecutionReportTradeAddendumSpreadLeg550.h | 6 +- .../gen/src/ExecutionReportTradeOutright525.h | 6 +- .../gen/src/ExecutionReportTradeSpread526.h | 6 +- .../src/ExecutionReportTradeSpreadLeg527.h | 6 +- .../order_execution/gen/src/ExpCycle.h | 6 +- .../spartan/order_execution/gen/src/FTI.h | 6 +- .../order_execution/gen/src/GroupSize.h | 6 +- .../order_execution/gen/src/KeepAliveLapsed.h | 6 +- .../order_execution/gen/src/ListUpdAct.h | 6 +- .../order_execution/gen/src/ManualOrdInd.h | 6 +- .../order_execution/gen/src/ManualOrdIndReq.h | 6 +- .../gen/src/MassActionOrdTyp.h | 6 +- .../gen/src/MassActionResponse.h | 6 +- .../order_execution/gen/src/MassActionScope.h | 6 +- .../order_execution/gen/src/MassCancelTIF.h | 6 +- .../order_execution/gen/src/MassCxlReqTyp.h | 6 +- .../order_execution/gen/src/MassQuote517.h | 6 +- .../order_execution/gen/src/MassQuoteAck545.h | 6 +- .../gen/src/MassStatusOrdTyp.h | 6 +- .../gen/src/MassStatusReqTyp.h | 6 +- .../order_execution/gen/src/MassStatusTIF.h | 6 +- .../gen/src/MaturityMonthYear.h | 6 +- .../order_execution/gen/src/MessageHeader.h | 6 +- .../order_execution/gen/src/Negotiate500.h | 6 +- .../gen/src/NegotiationReject502.h | 6 +- .../gen/src/NegotiationResponse501.h | 6 +- .../gen/src/NewOrderCross544.h | 6 +- .../gen/src/NewOrderSingle514.h | 6 +- .../order_execution/gen/src/NotApplied513.h | 6 +- .../order_execution/gen/src/OFMOverrideReq.h | 6 +- .../order_execution/gen/src/OrdStatusTrd.h | 6 +- .../order_execution/gen/src/OrdStatusTrdCxl.h | 6 +- .../gen/src/OrderCancelReject535.h | 6 +- .../gen/src/OrderCancelReplaceReject536.h | 6 +- .../gen/src/OrderCancelReplaceRequest515.h | 6 +- .../gen/src/OrderCancelRequest516.h | 6 +- .../order_execution/gen/src/OrderEventType.h | 6 +- .../gen/src/OrderMassActionReport562.h | 6 +- .../gen/src/OrderMassActionRequest529.h | 6 +- .../gen/src/OrderMassStatusRequest530.h | 6 +- .../order_execution/gen/src/OrderStatus.h | 6 +- .../gen/src/OrderStatusRequest533.h | 6 +- .../order_execution/gen/src/OrderType.h | 6 +- .../order_execution/gen/src/OrderTypeReq.h | 6 +- .../spartan/order_execution/gen/src/PRICE9.h | 6 +- .../order_execution/gen/src/PRICENULL9.h | 6 +- .../order_execution/gen/src/PartyDetailRole.h | 6 +- .../src/PartyDetailsDefinitionRequest518.h | 6 +- .../src/PartyDetailsDefinitionRequestAck519.h | 6 +- .../gen/src/PartyDetailsListReport538.h | 6 +- .../gen/src/PartyDetailsListRequest537.h | 6 +- .../order_execution/gen/src/QuoteAckStatus.h | 6 +- .../order_execution/gen/src/QuoteCancel528.h | 6 +- .../gen/src/QuoteCancelAck563.h | 6 +- .../order_execution/gen/src/QuoteCxlStatus.h | 6 +- .../order_execution/gen/src/QuoteCxlTyp.h | 6 +- .../order_execution/gen/src/QuoteTyp.h | 6 +- .../spartan/order_execution/gen/src/RFQSide.h | 6 +- .../order_execution/gen/src/ReqResult.h | 6 +- .../gen/src/RequestForQuote543.h | 6 +- .../gen/src/RequestForQuoteAck546.h | 6 +- .../gen/src/Retransmission509.h | 6 +- .../gen/src/RetransmitReject510.h | 6 +- .../gen/src/RetransmitRequest508.h | 6 +- .../spartan/order_execution/gen/src/SLEDS.h | 6 +- .../spartan/order_execution/gen/src/SMPI.h | 6 +- .../order_execution/gen/src/SecRspTyp.h | 6 +- .../gen/src/SecurityDefinitionRequest560.h | 6 +- .../gen/src/SecurityDefinitionResponse561.h | 6 +- .../order_execution/gen/src/Sequence506.h | 6 +- .../order_execution/gen/src/ShortSaleType.h | 6 +- .../order_execution/gen/src/SideNULL.h | 6 +- .../spartan/order_execution/gen/src/SideReq.h | 6 +- .../order_execution/gen/src/SideTimeInForce.h | 6 +- .../order_execution/gen/src/SplitMsg.h | 6 +- .../order_execution/gen/src/Terminate507.h | 6 +- .../order_execution/gen/src/TimeInForce.h | 6 +- .../order_execution/gen/src/TradeAddendum.h | 6 +- 173 files changed, 70050 insertions(+), 59410 deletions(-) create mode 100644 src/server/sparkd/cmds/spartan/market_data/gen/cert/templates_FixBinary.xml create mode 100755 src/server/sparkd/cmds/spartan/market_data/gen/generate.sh create mode 100644 src/server/sparkd/cmds/spartan/market_data/gen/nrcert/templates_FixBinary.xml create mode 100644 src/server/sparkd/cmds/spartan/market_data/gen/prod/templates_FixBinary.xml create mode 100644 src/server/sparkd/cmds/spartan/market_data/gen/sbe-all-1.20.4.jar diff --git a/src/server/sparkd/cmds/spartan/docs/cme_notes.org b/src/server/sparkd/cmds/spartan/docs/cme_notes.org index f3e1f27e3..16cc04c2d 100644 --- a/src/server/sparkd/cmds/spartan/docs/cme_notes.org +++ b/src/server/sparkd/cmds/spartan/docs/cme_notes.org @@ -1,3 +1,5 @@ +* MDP3 +- [[ftp://ftp.cmegroup.com/SBEFix/][Templates and Config FTP Site]] * iLink3 - [[https://cmegroup.com/confluence/display/EPICSANDBOX/iLink+3+-+Simple+Binary+Encoding#iLink3SimpleBinaryEncoding-SchemaDistribution][Dissimination Scheme]] - sftp access: diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/cert/templates_FixBinary.xml b/src/server/sparkd/cmds/spartan/market_data/gen/cert/templates_FixBinary.xml new file mode 100644 index 000000000..cb0c3ade3 --- /dev/null +++ b/src/server/sparkd/cmds/spartan/market_data/gen/cert/templates_FixBinary.xml @@ -0,0 +1,955 @@ + + + + + + + + 24 + + + + + + + J + g + 2 + e + + 0 + 0 + + + + 8 + + + + + + + + + + + + + + + + -9 + + + + -9 + + + + -4 + + + + -7 + + + + + + + + + + -7 + + + + -9 + + + + -7 + + + + -9 + + + + + + + + + + + + + + + + + + + + + 0 + 1 + 2 + + + 5 + 7 + + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + + + 1 + 2 + + + 0 + 1 + 2 + 4 + 6 + 7 + 8 + B + C + E + F + J + N + O + W + e + g + + + 0 + 1 + E + F + J + + + 6 + B + C + W + + + 4 + 7 + 8 + N + O + + + 0 + 1 + 2 + 3 + 4 + 5 + + + 0 + 5 + + + 0 + 1 + 2 + + + 0 + 1 + + + 0 + 1 + 4 + 5 + 6 + + + 2 + 4 + 15 + 17 + 18 + 20 + 21 + 24 + 25 + 26 + 103 + + + A + D + M + + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + + + 0 + 1 + 2 + 3 + 4 + 7 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/generate.sh b/src/server/sparkd/cmds/spartan/market_data/gen/generate.sh new file mode 100755 index 000000000..031db8105 --- /dev/null +++ b/src/server/sparkd/cmds/spartan/market_data/gen/generate.sh @@ -0,0 +1,42 @@ +#!/bin/bash + + +# To update templates_FixBinary.xml: +# ---------------------------------- +# Download the new template from one of the above: +# ftp://ftp.cmegroup.com/SBEFix/Production/Templates/templates_FixBinary.xml +# ftp://ftp.cmegroup.com/SBEFix/NRCert/Templates/templates_FixBinary.xml +# ftp://ftp.cmegroup.com/SBEFix/Cert/Templates/templates_FixBinary.xml +# And copy it to the corresponding directory (prod, nrcert, cert) +# ---------------------------------- + +# To generate CPP +# --------------------------- +# Obtain sbe-all-[version].jar from sbe-logic github. +# Pre-built packages are available at https://search.maven.org/search?q=g:uk.co.real-logic%20sbe +# Run the docker command below which run a java docker container and execute the jar. + +RELEASE_TYPE=${1:-prod} +SBE_VERSION=1.20.4 + +SBE_BIN=sbe-all-$SBE_VERSION.jar +MY_DIR="$(dirname "$(readlink -f "$0")")" +cd $MY_DIR +rm -rf src +mkdir -p src + +docker run --rm -it -w $PWD \ + -v /home:/home \ + -v /etc/group:/etc/group \ + -v /etc/passwd:/etc/passwd \ + -u $UID \ + java \ + java -Dsbe.output.dir=src \ + -Dsbe.generate.ir="false" \ + -Dsbe.target.namespace="mdp3" \ + -Dsbe.target.language=cpp \ + -jar ./sbe-all-$SBE_VERSION.jar \ + $RELEASE_TYPE/templates_FixBinary.xml + +mv src/mdp3/* src/ +rmdir src/mdp3/ diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/nrcert/templates_FixBinary.xml b/src/server/sparkd/cmds/spartan/market_data/gen/nrcert/templates_FixBinary.xml new file mode 100644 index 000000000..cb0c3ade3 --- /dev/null +++ b/src/server/sparkd/cmds/spartan/market_data/gen/nrcert/templates_FixBinary.xml @@ -0,0 +1,955 @@ + + + + + + + + 24 + + + + + + + J + g + 2 + e + + 0 + 0 + + + + 8 + + + + + + + + + + + + + + + + -9 + + + + -9 + + + + -4 + + + + -7 + + + + + + + + + + -7 + + + + -9 + + + + -7 + + + + -9 + + + + + + + + + + + + + + + + + + + + + 0 + 1 + 2 + + + 5 + 7 + + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + + + 1 + 2 + + + 0 + 1 + 2 + 4 + 6 + 7 + 8 + B + C + E + F + J + N + O + W + e + g + + + 0 + 1 + E + F + J + + + 6 + B + C + W + + + 4 + 7 + 8 + N + O + + + 0 + 1 + 2 + 3 + 4 + 5 + + + 0 + 5 + + + 0 + 1 + 2 + + + 0 + 1 + + + 0 + 1 + 4 + 5 + 6 + + + 2 + 4 + 15 + 17 + 18 + 20 + 21 + 24 + 25 + 26 + 103 + + + A + D + M + + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + + + 0 + 1 + 2 + 3 + 4 + 7 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/prod/templates_FixBinary.xml b/src/server/sparkd/cmds/spartan/market_data/gen/prod/templates_FixBinary.xml new file mode 100644 index 000000000..cb0c3ade3 --- /dev/null +++ b/src/server/sparkd/cmds/spartan/market_data/gen/prod/templates_FixBinary.xml @@ -0,0 +1,955 @@ + + + + + + + + 24 + + + + + + + J + g + 2 + e + + 0 + 0 + + + + 8 + + + + + + + + + + + + + + + + -9 + + + + -9 + + + + -4 + + + + -7 + + + + + + + + + + -7 + + + + -9 + + + + -7 + + + + -9 + + + + + + + + + + + + + + + + + + + + + 0 + 1 + 2 + + + 5 + 7 + + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + + + 1 + 2 + + + 0 + 1 + 2 + 4 + 6 + 7 + 8 + B + C + E + F + J + N + O + W + e + g + + + 0 + 1 + E + F + J + + + 6 + B + C + W + + + 4 + 7 + 8 + N + O + + + 0 + 1 + 2 + 3 + 4 + 5 + + + 0 + 5 + + + 0 + 1 + 2 + + + 0 + 1 + + + 0 + 1 + 4 + 5 + 6 + + + 2 + 4 + 15 + 17 + 18 + 20 + 21 + 24 + 25 + 26 + 103 + + + A + D + M + + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 + 21 + + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + + + 0 + 1 + 2 + 3 + 4 + 7 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/sbe-all-1.20.4.jar b/src/server/sparkd/cmds/spartan/market_data/gen/sbe-all-1.20.4.jar new file mode 100644 index 0000000000000000000000000000000000000000..94e4be40cc05b44bc7bcbbb73283e2881c9f614d GIT binary patch literal 731051 zcmb5V1CVA-vo6}xc2C>3ZJTe~wrv~Jp0;hlz0Wy!fA`+=$A4DTs#Osy zvm$CmR<6n?pOlvd0fhzvf`kOB6iQYA`g;NYNB8%F`g;RJl?7=fWyR=0faL!nnEgxZ zyX>z3@ed#%l>aUW5R{b^6ID{C1BkiAbioHQpoBb=`Gj=~V6(_t8)C@x3jV5~JQT9E z_JX1fva?$q%z50n-nd^}+Xo^X$NuwU?AWk`X==*0ey3L)SBXL^3e9mAh16_>G+w$c zj`cAT%wv{rGdYZ@&~)a>)m(hto}c% z|L-E;|0QB%_b;Uo|F@K*iGj7AwVj!T(Z5tc{r^*NGBo*@N*MnqB@4%YsYmoL^vq0b zO&krJO^p9BL&aZX;px96jD-gRlBWRz;{3N}5OXxJF%h;iHZc-0G5Y&(q%*QMaB`Z| zu+rBScj04xU$8V8qn>D{8B@(%SsIu+BINcR8;n16-%mo(ioh9>t*lsVYJ9SEYv_ou zu@ADafQ+3Jl2D=``H}up$oxWoj1dZow6QQzT-aRNJdbuph|&V4NFd|qGk1eq%~e-N z{W2r`$IV6>^YNcQZc}M?Q{#HxkMnZK3Sp_pxo{6MU~MN2d~eMBJ~18Bj`tq6Uzr&_ zJ4Y}-Sf(AW>8Vd5AJlx`;?FUXcf?w^ypR5*LBBEi6vcN-`CXPAYrI?Wxc7-VAIbQ4 z%lZur^c)^tx4wqP>cYx{_{@v@T^IO4&KSO-Y4HwBw)i~6{?JUv|3H5JT9w=0y>@GR z&CdB6lKURtyna80@O@+F|NO1;y(!1PcP;JvhVb=OlJgbW!~Zld_wv5&`$p;a9TxEM zN1PuW-%G61diM^1N%mpYnH+Q@*dkZ^11H$V`w7FIS zvK-@NYiYg%6IjqG>PvolDnP;y-|Ba+z_KmI!}Z2ogVIdr$&X7{+RUhuejRZ~Pd`)T zY3p8F3)%v5r!G⋼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 z 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

?eq1-!Grv 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�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%0AV%NPY0#GCgMw5dyq zY?LNbL;U?qb!jB?sy_~aSzIBhB1xBBw2ElXV-3MUMjDcth?$9}Fq~xb^rwuM_z6)8 zr%a(!;}4|Xk)6-ZE@%>u_fY&fhsIJ495m%egepxvh;6o{h0?2S5Y@jGA+|MV9Lnsl1}9EFnarUjRrw6b_#DBICas?3a2VO;H1(r04ZUj zkZYCY&lnNd1`jpHKuQg;8kq=WrVAF{XOUGzM&r#XggE*4zVmY<%`Y&6h)K0S^$q2JH(5cBrLh*o$Oy6z-GUgK* zW6Iz-6O&Q9B|fhhsN?HI+kY3+S`t*y#vYGsaeC>78fgfOn{hxqAUql8nbv-p4ZgM3 zJr38{RI62!YX;ZqsMqQ!H|az^-lLpH)jeWD){XUXk61*GJImgf4}^>jPJv!H@k7RB z-OwOz9a3U3)ZxJhf%-6}G=!#)CYmu>`##L8oZ0_s%k7^sl7|2pe6V&XHmypu>-ey0 zf)*^Y&QTn2%MBp7eLnbG*U6HzNhTOz$x=$?(x@!oaii<2)VL zG6IkmCIJh<8vc`Op#E&1Q`Julmygm#hTDD~-s-8*_e`t!?tB-d+16H&YVAcDjKZH>-;B_4+pX z4w){IXeX)C%u5Lail|$dE^d-Olx_{})3E1Xo_K-xmKH_Ze;;i54|wZ#o-<}xGgt+g zWIXwM;OfCzsQ3m5MosAM>}pr(U8B)3TEo+|P7@wCN&*ZQyoXD^B=XyE@_mGS&@w-} zsow{=$G?Ctz-lh0%^?5qr+h(L;^G%>(W#?S)>}!A*7-=x@!F{W8Lj(@GhWX&ST)hR zD30bz$^=5}_h9vk2h>czetT+Zrm^mldMr;0O5Q4=X&Mmz|a&q>W372hqlcUqYuiO;brTHbnsC4~LQx?O;dMK`Q4k6ZA(s>1>sN~$l8j{6{4zMd(Z9=b_=;$ z?Odff4EA&OAIzOH#vaV#VvfIzU`mo7E*vbI=pAB@y*cN~_ExNJrxYz%V|G~C#BC$J zI8=i}!b5sxG0U@nLAw582)0|>!(ZHTkiys}m4$x`vKM=+U4H>SUW z;`v#=5Kr=`_5TfIxC7sJlcRdapZH_N)=l!_n@!<;0Zq2rhj_!2Wf>MNe%;8mK<^NY zDQY9H_{qd(Zhu2c(<PAIi&A5Pp`WTBsC5twhh1+CbGOj!_3yn6{T zm)X4D0^0@HTzW`KW2^#Utj_^)DCo2z?*sB{B2=5aX$fjUL#74>Sn~+HsVU@i9*Wd_ zR=e8&601SWt$spVJ7M46wBAfzXk*+m29P(+>*HO3yRzuvdLY_II zQG(Rn-^j0;Toj!EW~O&>(YQ&;t)`Q^MZWUtwdb1o@eb!iQFw zq{nz5c3%P|xidFS+D+d-n-X9uF>N?3yU_ zJF4v^hS4v*&a48dk1$Id^g8_L-z$y&*~mtij3|oy98#^I{`!UW|Iu~MCML!X|1Iqr zRXx2lm2tkaSVyJj+Fc}twc*b#an0eJ~_;$;r@M7V7B&L=+{!*QDL9u-|ShL&ZyV*S@M%?5Bj?lAze z8~0_%Ann?LL~l62n)XYOTzBtXynJo1j?xVQ+g^`wyIPk+>GpWJq8veyWH_@9W|Ciy zeZIsGcY%vu27xk8_{n7U2w=Ta1>qb|kb`j%Zcxa&!m3wqox!?%Z8>jgywY`lpA8tg zWe9HXB6g4Gk^y^7N0DW^LCW6uU$57y_At4W$Z&__*^zOZ4(o&Ygy3=98h#9fmft7> z{I1_W&NxAH`Iw9H|2R{1(IVJc2F!Bpi{1uz$k_b!?TK-%nMN}jSv@pXTiRSZ z#=AK+73Ar>?9vH3^pz~=R1o|rd2)jzKES1+www%DTU%e}WIwQmK{OHl>4h`g!-+BG zq+$C_9))w3#1PNCqQnxR92 z8W*#>)ZP_g^Qu7+x1><~C`dVXDgixkfp9#M1Zs!2njs;QKpC}gE4QkM%OkX|z=Kxn zKnd!)=|B!SP%fSKhSZ?U>;|I3BsNk%Mjb^9hLCj`ax~IBb{32!BW;^uuaVipi1GGU z4EI$0U-)En^{ph8Sq?(7A~qFm$1IiFm8^r7zi1G!C-mmK(TH)haz!t;Y8?)HiJ;o| zRzyt76j|C>U_^tE7ChjxwR&3CgYQho}%<@K^XUa0l%k zOhysws_|XY#(u5$06waHcIPUOHX{vTBNC~=V9JPtTGa^khoLd6F9cydQ+kMZi_*X^ z7X>+?BRv@eG`-@HyA*PRnZHT&$R^@8zK7uze`yLaBS@8%^~Qyc3<3c)Y3m48sPmvU z0W}Hg5-Ws+;9No~5)wn%@jA_e>LsHb{y6=V3<))*C5Bh{wNen6+&E$TRwCGwXj0WN zsTKAtg~bcj3u}+YRF2R3+6wjZt@v5Rz&GjbmJ=S<$Ba- zu|L15>x}5Ba5}D~N025kxWC24g}fJ&pF81mIC?_%w>2w;L6@Tq=0_wC4Ih%TEOW~0 z*{CzCPI56)6{fPyO$}CmhHI}QG3Rovx$hBNBGUwZ7Ji66480MTz|UCnzAUPSnXy zE#F@rJbN)!6X9R=0!;~Ys8G?P7tn&4&X}f0Shjsa&s7dnk6%H^N+)v`LhJU79IfS1 zqa92FG1fp&rYcCKmyYfKFc0Wzei+xz#XD0v;#w9pf=5bV@{o{Yl)4bpY?xe73|4%4 z;|Qjg^a0(+NEaNb3unl9a}@$NN2(=wq82Uc%2vI?S>8D+NsxQax9_#;OaAVLdcfFC z+;ez)Y}{bF7Vc%L(VHSLm!@nQCs3X{unQ(Ex6M^Fa}X*7XFfUkxW$_%%CnunQ*}or z-a%36a&z5Zm48gaBXard%-2+852yZ&8_VXv452W}Ewr@*V~MB(A--{iBKc4oDst}n zeaz)X5Xk}cg@i9q9StBXNlY@PU@jk3w2pT8LW;X5`z|JRo-`!(?QDxU-%vg^5yuuz z>05uYZ2s3Lj7zQ$jEA4ZYv`Ox+RYm#%`&_7>D-dykIl(B$Ps5r^@k{D=Tpy(%vz=( zRsN!eH{b<307uJ+5THSg9yS^hF{T)LpN%#KL_euN1t*Hxrpo7yh~(f|ze0RtpM5_K ze0ZgBQa{^9P`wPH=?$?1m~78pU6Ee77{A>rgj%Lw{~>YCh=3fVI~jh~9_PUsCo+=h z4*uzl&D=2~;|2Uw|GSen=3~1x_$lqKTuOuqCoz!#Hnmx?s&Rk{S(8D6O{Lt)R#e8a zd>^%Q8%lDD3b&cYta@f&+;=z*o-d4QJYF?FMwLI_vgyjKxXZ=tP0OrG9M;{$L~X4>C!55PbQ>TXkwdM^!M&C$E{8faG| zA&GD&J(!us9AeGcO z^~S{#<1VuL&Z?KlW1W^`)Vuw`RU2kBRCPgYYZj8>R_%%s1JXJ9o+^2S;AUQyrKWHNN{9|l3w zkYZ=P7~jX|UUV$4MJFMyeyCHf^$6FFE5MY|dKBL7N(ySO$W){?SvfEODvrQY5N;L< zC7h6+IVO-S!=b5SrCR|Ois=@V5mH}wm*F(*Q56)CQ*}JA+6IZt6aKP&Lk>mbwjNoaRT5=sA^lMh#(Eum3czP(!?vO zGXsvvldOJ2eB(DB$ea;zC@oT==u)Zd({4!POyzOiDkRLi;*fZ=Bq{-I+T;)18Uj^1 zGqYlv+cD3s3Gmc~i-^Ge_!TnxJv7IExyAl-6!*f$TQbGyS62FqCouZ&ZpHt|Z&x>b9krh_L-HSELhS#P--1@Q zj>clfR(Ai}0yRn7O3@g7`1{&pZN9p;x9fx#J*1}UQU$$+e>hBTIC+z=nV@%I#+ghr zw;}%=zT+0uaKTMKg25sJLC}SYln}iRp00=?XeaWv&rGP3mDC~z|Ngs+hv$5Qb1x|~ z`k4Fro%j3up6hx_6^=I@qy|T}T|N{SE@P$CFc}QtVXWTVB(U9(`RbOzz ze|WaqusaF}Flw_@iV_c{=5;+9!mRcpg+LBP);OZ~lqp}thMghJ#7LSuU8*3O#DT)y z7PRq0$U;KTnmZi}j%>(rRf-T>(zH0jU&Lc>QVyL7R1Y#34}8EF7)8kcc7rmFAPIN&BT^-a`#AL{#A(+d%S2~gfaX7 zVeB1)Gz+3_!9th2Y*&|U8(p?-yUVuSW!vtrY=33jwrxz^``*mld*6?lh@BB9GR~i~ zW}jgVIJz}J1`fr)_&C1bElG#$s*H|jp2hjE>(NU z+&9x}17emGvqJT%A?u`~(Z!U^kVAf(h+_B!2MvR3zgVxbp^XCyofYpV1y}A=*2hv( zngucjky5+^Ahn9eOe}RkhG{efxgKvo3nn-gDZ3tCJcsyAk)TMrsSED`5Gk}1tCw-( zdKW7c=KA)EG)gP&X!w}wwKvtPw@}1`Bz1Vqb&1{_Z;Wy;%0DOLRDdPDJMS?8^*5#I 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 z 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⁣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%0A%c}o2Xf(nW;T&mk7Vy6P^YZEln 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

ZYp6t+NPv3AB^h31@(GeAul@W(onpE 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 hu;h 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 G!Tb*{+|j83 literal 0 HcmV?d00001 diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/AdminHeartbeat12.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/AdminHeartbeat12.h index d8120ef04..bbbfe8022 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/AdminHeartbeat12.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/AdminHeartbeat12.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,195 +86,268 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class AdminHeartbeat12 { - 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 AdminHeartbeat12 +{ +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; } + 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(0); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(12); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - AdminHeartbeat12() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - AdminHeartbeat12( - 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; - AdminHeartbeat12(char *buffer, const std::uint64_t bufferLength) - : AdminHeartbeat12( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + AdminHeartbeat12() = default; - AdminHeartbeat12( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : AdminHeartbeat12( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + AdminHeartbeat12( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + AdminHeartbeat12(char *buffer, const std::uint64_t bufferLength) : + AdminHeartbeat12(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)12; - } + AdminHeartbeat12( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + AdminHeartbeat12(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(0); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "0"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(12); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - AdminHeartbeat12 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = AdminHeartbeat12( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - AdminHeartbeat12 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "0"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = AdminHeartbeat12( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + AdminHeartbeat12 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = AdminHeartbeat12(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - AdminHeartbeat12 &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 = AdminHeartbeat12( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + AdminHeartbeat12 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = AdminHeartbeat12( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + AdminHeartbeat12 &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 = AdminHeartbeat12(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + AdminHeartbeat12 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, AdminHeartbeat12 _writer) { - AdminHeartbeat12 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "AdminHeartbeat12", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - builder << '}'; + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - return builder; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } + + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, AdminHeartbeat12 _writer) +{ + AdminHeartbeat12 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "AdminHeartbeat12", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + 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 + std::size_t length = sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/AdminLogin15.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/AdminLogin15.h index f0f5df257..d69e49bc3 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/AdminLogin15.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/AdminLogin15.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,263 +86,342 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class AdminLogin15 { - 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 AdminLogin15 +{ +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; } + 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(1); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(15); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - AdminLogin15() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - AdminLogin15( - 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; - AdminLogin15(char *buffer, const std::uint64_t bufferLength) - : AdminLogin15( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + AdminLogin15() = default; - AdminLogin15( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : AdminLogin15( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + AdminLogin15( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + AdminLogin15(char *buffer, const std::uint64_t bufferLength) : + AdminLogin15(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)15; - } + AdminLogin15( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + AdminLogin15(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(1); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "A"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(15); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - AdminLogin15 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = AdminLogin15( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - AdminLogin15 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "A"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = AdminLogin15( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + AdminLogin15 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = AdminLogin15(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - AdminLogin15 &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 = AdminLogin15( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + AdminLogin15 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = AdminLogin15( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + AdminLogin15 &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 = AdminLogin15(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + AdminLogin15 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char * - HeartBtIntMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t heartBtIntId() SBE_NOEXCEPT { - return 108; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - heartBtIntSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool heartBtIntInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *HeartBtIntMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t heartBtIntId() SBE_NOEXCEPT + { + return 108; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t heartBtIntSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool heartBtIntInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= heartBtIntSinceVersion(); + return m_actingVersion >= heartBtIntSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - heartBtIntEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t heartBtIntEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::int8_t heartBtIntNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } + static SBE_CONSTEXPR std::int8_t heartBtIntNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } - static SBE_CONSTEXPR std::int8_t heartBtIntMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } + static SBE_CONSTEXPR std::int8_t heartBtIntMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } - static SBE_CONSTEXPR std::int8_t heartBtIntMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t heartBtIntMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::size_t heartBtIntEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t heartBtIntEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::int8_t heartBtInt() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int8_t)); - return (val); - } + SBE_NODISCARD std::int8_t heartBtInt() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int8_t)); + return (val); + } - AdminLogin15 &heartBtInt(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int8_t)); - return *this; - } + AdminLogin15 &heartBtInt(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int8_t)); + return *this; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, AdminLogin15 _writer) { - AdminLogin15 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "AdminLogin15", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, AdminLogin15 _writer) +{ + AdminLogin15 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "AdminLogin15", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << R"("HeartBtInt": )"; - builder << +writer.heartBtInt(); + builder << R"("HeartBtInt": )"; + builder << +writer.heartBtInt(); - builder << '}'; + builder << '}'; - return 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 +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/AdminLogout16.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/AdminLogout16.h index 805ce83a7..bc07e1800 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/AdminLogout16.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/AdminLogout16.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,382 +86,478 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class AdminLogout16 { - 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 AdminLogout16 +{ +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; } + 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(180); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(16); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - AdminLogout16() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - AdminLogout16( - 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; - AdminLogout16(char *buffer, const std::uint64_t bufferLength) - : AdminLogout16( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + AdminLogout16() = default; - AdminLogout16( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : AdminLogout16( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + AdminLogout16( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)180; - } + AdminLogout16(char *buffer, const std::uint64_t bufferLength) : + AdminLogout16(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)16; - } + AdminLogout16( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + AdminLogout16(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(180); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "5"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(16); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - AdminLogout16 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = AdminLogout16( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - AdminLogout16 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "5"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = AdminLogout16( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + AdminLogout16 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = AdminLogout16(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - AdminLogout16 &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 = AdminLogout16( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + AdminLogout16 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = AdminLogout16( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + AdminLogout16 &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 = AdminLogout16(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + AdminLogout16 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char * - TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t textId() SBE_NOEXCEPT { return 58; } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - textSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool textInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *TextMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + 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(); + return m_actingVersion >= textSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - textEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t textEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - 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 180; - } + static SBE_CONSTEXPR std::size_t textEncodingLength() SBE_NOEXCEPT + { + return 180; + } - static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT { return 180; } + static SBE_CONSTEXPR std::uint64_t textLength() SBE_NOEXCEPT + { + return 180; + } - SBE_NODISCARD const char *text() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } + SBE_NODISCARD const char *text() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - SBE_NODISCARD char *text() SBE_NOEXCEPT { return m_buffer + m_offset + 0; } + SBE_NODISCARD char *text() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - SBE_NODISCARD char text(const std::uint64_t index) const { - if (index >= 180) { - throw std::runtime_error("index out of range for text [E104]"); - } + SBE_NODISCARD char text(const std::uint64_t index) const + { + if (index >= 180) + { + throw std::runtime_error("index out of range for text [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); + } - AdminLogout16 &text(const std::uint64_t index, const char value) { - if (index >= 180) { - throw std::runtime_error("index out of range for text [E105]"); - } + AdminLogout16 &text(const std::uint64_t index, const char value) + { + if (index >= 180) + { + throw std::runtime_error("index out of range for text [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 getText(char *const dst, const std::uint64_t length) const { - if (length > 180) { - 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 > 180) + { + throw std::runtime_error("length too large for getText [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; + } - AdminLogout16 &putText(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 180); - return *this; - } + AdminLogout16 &putText(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 180); + return *this; + } - std::string getTextAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; + SBE_NODISCARD std::string getTextAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + size_t length = 0; - for (; length < 180 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 180 && *(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 (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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getTextAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getTextAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + size_t length = 0; - for (; length < 180 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 180 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } + return result; + } + #endif + + #if __cplusplus >= 201703L + AdminLogout16 &putText(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 180) + { + throw std::runtime_error("string too large for putText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (size_t start = srcLength; start < 180; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #else + AdminLogout16 &putText(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 180) + { + throw std::runtime_error("string too large for putText [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (size_t start = srcLength; start < 180; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #endif + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, AdminLogout16 _writer) +{ + AdminLogout16 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "AdminLogout16", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("Text": )"; + builder << '"' << + writer.getTextAsJsonEscapedString().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(); -#if __cplusplus >= 201703L - AdminLogout16 &putText(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 180) { - throw std::runtime_error("string too large for putText [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 180; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#else - AdminLogout16 &putText(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 180) { - throw std::runtime_error("string too large for putText [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 180; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop #endif - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, AdminLogout16 _writer) { - AdminLogout16 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "AdminLogout16", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("Text": )"; - builder << '"' << writer.getTextAsJsonEscapedString().c_str() << '"'; - - builder << '}'; - - return builder; - } +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/AggressorSide.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/AggressorSide.h index fe1c5343f..6aa48c603 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/AggressorSide.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/AggressorSide.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,54 +86,54 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class AggressorSide { - public: - enum Value { - NoAggressor = (std::uint8_t)0, - Buy = (std::uint8_t)1, - Sell = (std::uint8_t)2, - NULL_VALUE = (std::uint8_t)255 - }; +class AggressorSide +{ +public: + enum Value + { + NoAggressor = static_cast(0), + Buy = static_cast(1), + Sell = static_cast(2), + NULL_VALUE = static_cast(255) + }; - static AggressorSide::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return NoAggressor; - case 1: - return Buy; - case 2: - return Sell; - case 255: - return NULL_VALUE; - } + static AggressorSide::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return NoAggressor; + 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 AggressorSide [E103]"); - } + throw std::runtime_error("unknown value for enum AggressorSide [E103]"); + } - static const char *c_str(const AggressorSide::Value value) { - switch (value) { - case NoAggressor: - return "NoAggressor"; - case Buy: - return "Buy"; - case Sell: - return "Sell"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const AggressorSide::Value value) + { + switch (value) + { + case NoAggressor: return "NoAggressor"; + case Buy: return "Buy"; + case Sell: return "Sell"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum AggressorSide [E103]:"); - } + throw std::runtime_error("unknown value for enum AggressorSide [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, AggressorSide::Value m) { - return os << AggressorSide::c_str(m); - } + template + friend std::basic_ostream& operator << ( + std::basic_ostream& os, AggressorSide::Value m) + { + return os << AggressorSide::c_str(m); + } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/ChannelReset4.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/ChannelReset4.h index c0a8ee32c..eef1353e2 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/ChannelReset4.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/ChannelReset4.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,774 +86,919 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class ChannelReset4 { - 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 ChannelReset4 +{ +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; } + 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(9); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(4); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - ChannelReset4() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - ChannelReset4( - 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; - ChannelReset4(char *buffer, const std::uint64_t bufferLength) - : ChannelReset4( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + ChannelReset4() = default; - ChannelReset4( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : ChannelReset4( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + ChannelReset4( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + ChannelReset4(char *buffer, const std::uint64_t bufferLength) : + ChannelReset4(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)4; - } + ChannelReset4( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + ChannelReset4(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(9); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "X"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(4); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - ChannelReset4 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = ChannelReset4( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - ChannelReset4 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "X"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = ChannelReset4( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + ChannelReset4 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = ChannelReset4(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - ChannelReset4 &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 = ChannelReset4( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + ChannelReset4 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = ChannelReset4( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + ChannelReset4 &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 = ChannelReset4(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + ChannelReset4 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + 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(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - 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 + 0, 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - ChannelReset4 &transactTime(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; - } + ChannelReset4 &transactTime(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 *MatchEventIndicatorMetaAttribute( - 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 *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - class NoMDEntries { + class NoMDEntries + { 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(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; + } + + 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 NoMDEntries &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(static_cast(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 *MDUpdateActionMetaAttribute(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 mDUpdateActionId() SBE_NOEXCEPT + { + return 279; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDUpdateActionSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::int8_t mDUpdateActionNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t mDUpdateActionMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t mDUpdateActionMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::int8_t mDUpdateAction() SBE_NOEXCEPT + { + return static_cast(0); + } + + SBE_NODISCARD static const char *MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT + { + return 269; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR char mDEntryTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char mDEntryTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char mDEntryTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t mDEntryTypeLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *mDEntryType() const + { + static const std::uint8_t mDEntryTypeValues[] = { 74 }; + + return (const char *)mDEntryTypeValues; + } + + SBE_NODISCARD char mDEntryType(const std::uint64_t index) const + { + static const std::uint8_t mDEntryTypeValues[] = { 74 }; + + return (char)mDEntryTypeValues[index]; + } + + std::uint64_t getMDEntryType(char *dst, const std::uint64_t length) const + { + static std::uint8_t mDEntryTypeValues[] = { 74 }; + std::uint64_t bytesToCopy = length < sizeof(mDEntryTypeValues) ? length : sizeof(mDEntryTypeValues); + + std::memcpy(dst, mDEntryTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getMDEntryTypeAsString() const + { + static const std::uint8_t MDEntryTypeValues[] = { 74 }; + + return std::string((const char *)MDEntryTypeValues, 1); + } + + std::string getMDEntryTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getMDEntryTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + 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 *ApplIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t applIDId() SBE_NOEXCEPT + { + return 1180; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t applIDSinceVersion() SBE_NOEXCEPT + { + return 3; + } + + SBE_NODISCARD bool applIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= applIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t applIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::int16_t applIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT16; + } + + static SBE_CONSTEXPR std::int16_t applIDMinValue() SBE_NOEXCEPT + { + return static_cast(-32767); + } + + static SBE_CONSTEXPR std::int16_t applIDMaxValue() SBE_NOEXCEPT + { + return static_cast(32767); + } + + static SBE_CONSTEXPR std::size_t applIDEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::int16_t applID() const SBE_NOEXCEPT + { + if (m_actingVersion < 3) + { + return static_cast(-32768); + } + + std::int16_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + NoMDEntries &applID(const std::int16_t value) SBE_NOEXCEPT + { + std::int16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int16_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDEntries writer) + { + builder << '{'; + builder << R"("ApplID": )"; + builder << +writer.applID(); + + 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)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; - } +private: + NoMDEntries m_noMDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 2; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDEntriesId() SBE_NOEXCEPT + { + return 268; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDEntries &noMDEntries() + { + m_noMDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDEntries &noMDEntriesCount(const std::uint8_t count) + { + m_noMDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDEntriesSinceVersion() 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 NoMDEntries &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 *MDUpdateActionMetaAttribute( - 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 mDUpdateActionId() SBE_NOEXCEPT { - return 279; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDUpdateActionSinceVersion() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDUpdateActionSinceVersion(); + return m_actingVersion >= noMDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 0; - } +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, ChannelReset4 _writer) +{ + ChannelReset4 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "ChannelReset4", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - static SBE_CONSTEXPR std::int8_t mDUpdateActionNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); - static SBE_CONSTEXPR std::int8_t mDUpdateActionMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } + builder << ", "; + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); - static SBE_CONSTEXPR std::int8_t mDUpdateActionMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingLength() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::int8_t - mDUpdateAction() SBE_NOEXCEPT { - return (std::int8_t)0; - } - - SBE_NODISCARD static const char * - MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT { - return 269; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR char mDEntryTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char mDEntryTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char mDEntryTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t mDEntryTypeLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *mDEntryType() const { - static const std::uint8_t mDEntryTypeValues[] = {74}; - - return (const char *)mDEntryTypeValues; - } - - SBE_NODISCARD char mDEntryType(const std::uint64_t index) const { - static const std::uint8_t mDEntryTypeValues[] = {74}; - - return (char)mDEntryTypeValues[index]; - } - - std::uint64_t - getMDEntryType(char *dst, const std::uint64_t length) const { - static std::uint8_t mDEntryTypeValues[] = {74}; - std::uint64_t bytesToCopy = length < sizeof(mDEntryTypeValues) - ? length - : sizeof(mDEntryTypeValues); - - std::memcpy(dst, mDEntryTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getMDEntryTypeAsString() const { - static const std::uint8_t MDEntryTypeValues[] = {74}; - - return std::string((const char *)MDEntryTypeValues, 1); - } - - std::string getMDEntryTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getMDEntryTypeAsString(); - - 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 * - ApplIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t applIDId() SBE_NOEXCEPT { - return 1180; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - applIDSinceVersion() SBE_NOEXCEPT { - return 3; - } - - SBE_NODISCARD bool applIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= applIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - applIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int16_t applIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT16; - } - - static SBE_CONSTEXPR std::int16_t applIDMinValue() SBE_NOEXCEPT { - return (std::int16_t)-32767; - } - - static SBE_CONSTEXPR std::int16_t applIDMaxValue() SBE_NOEXCEPT { - return (std::int16_t)32767; - } - - static SBE_CONSTEXPR std::size_t applIDEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::int16_t applID() const SBE_NOEXCEPT { - if (m_actingVersion < 3) { - return (std::int16_t)-32768; - } - - std::int16_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - NoMDEntries &applID(const std::int16_t value) SBE_NOEXCEPT { - std::int16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int16_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDEntries writer) { - builder << '{'; - builder << R"("ApplID": )"; - builder << +writer.applID(); - - builder << '}'; - - return builder; - } - }; - - private: - NoMDEntries m_noMDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDEntriesId() SBE_NOEXCEPT { - return 268; - } - - SBE_NODISCARD inline NoMDEntries &noMDEntries() { - m_noMDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - NoMDEntries &noMDEntriesCount(const std::uint8_t count) { - m_noMDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, ChannelReset4 _writer) { - ChannelReset4 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "ChannelReset4", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDEntries": [)"; - writer.noMDEntries().forEach([&](NoMDEntries &noMDEntries) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDEntries": [)"; + writer.noMDEntries().forEach([&](NoMDEntries& noMDEntries) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDEntries; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noMDEntries().forEach([](NoMDEntries e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t noMDEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoMDEntries::sbeHeaderSize(); + if (noMDEntriesLength > 254LL) + { + throw std::runtime_error("noMDEntriesLength outside of allowed range [E110]"); + } + length += noMDEntriesLength *NoMDEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/Decimal9.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/Decimal9.h index 04c6f16b2..9bcbfe850 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/Decimal9.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/Decimal9.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,210 +86,263 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class Decimal9 { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; +class Decimal9 +{ +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; + }; - Decimal9() = default; + Decimal9() = default; - Decimal9( - 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]"); - } - } + Decimal9( + 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]"); + } + } - Decimal9( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : Decimal9(buffer, 0, bufferLength, actingVersion) {} + Decimal9( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + Decimal9(buffer, 0, bufferLength, actingVersion) + { + } - Decimal9(char *buffer, const std::uint64_t bufferLength) - : Decimal9(buffer, 0, bufferLength, sbeSchemaVersion()) {} + Decimal9( + char *buffer, + const std::uint64_t bufferLength) : + Decimal9(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } - Decimal9 &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = Decimal9(buffer, offset, bufferLength, actingVersion); - } + Decimal9 &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = Decimal9(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)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mantissaSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t mantissaId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool mantissaInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mantissaSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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); + } - Decimal9 &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; - } + Decimal9 &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 ""; + } + } - 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 0; + } + + 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, Decimal9 writer) { - builder << '{'; - builder << R"("mantissa": )"; - builder << +writer.mantissa(); +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, Decimal9 writer) +{ + builder << '{'; + builder << R"("mantissa": )"; + builder << +writer.mantissa(); - builder << '}'; + builder << '}'; + + return builder; +} - return builder; - } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/Decimal9NULL.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/Decimal9NULL.h index 1090ee32b..83f3f96fe 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/Decimal9NULL.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/Decimal9NULL.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,210 +86,263 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class Decimal9NULL { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; +class Decimal9NULL +{ +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; + }; - Decimal9NULL() = default; + Decimal9NULL() = default; - Decimal9NULL( - 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]"); - } - } + Decimal9NULL( + 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]"); + } + } - Decimal9NULL( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : Decimal9NULL(buffer, 0, bufferLength, actingVersion) {} + Decimal9NULL( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + Decimal9NULL(buffer, 0, bufferLength, actingVersion) + { + } - Decimal9NULL(char *buffer, const std::uint64_t bufferLength) - : Decimal9NULL(buffer, 0, bufferLength, sbeSchemaVersion()) {} + Decimal9NULL( + char *buffer, + const std::uint64_t bufferLength) : + Decimal9NULL(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } - Decimal9NULL &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = Decimal9NULL(buffer, offset, bufferLength, actingVersion); - } + Decimal9NULL &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = Decimal9NULL(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)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mantissaSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t mantissaId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool mantissaInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mantissaSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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); + } - Decimal9NULL &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; - } + Decimal9NULL &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 ""; + } + } - 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 0; + } + + 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, Decimal9NULL writer) { - builder << '{'; - builder << R"("mantissa": )"; - builder << +writer.mantissa(); +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, Decimal9NULL writer) +{ + builder << '{'; + builder << R"("mantissa": )"; + builder << +writer.mantissa(); - builder << '}'; + builder << '}'; + + return builder; +} - return builder; - } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/DecimalQty.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/DecimalQty.h index 2f0664b58..ba707c96c 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/DecimalQty.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/DecimalQty.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,210 +86,263 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class DecimalQty { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; +class DecimalQty +{ +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; + }; - DecimalQty() = default; + DecimalQty() = default; - DecimalQty( - 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 + 4) > m_bufferLength), false)) { - throw std::runtime_error("buffer too short for flyweight [E107]"); - } - } + DecimalQty( + 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 + 4) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for flyweight [E107]"); + } + } - DecimalQty( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : DecimalQty(buffer, 0, bufferLength, actingVersion) {} + DecimalQty( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + DecimalQty(buffer, 0, bufferLength, actingVersion) + { + } - DecimalQty(char *buffer, const std::uint64_t bufferLength) - : DecimalQty(buffer, 0, bufferLength, sbeSchemaVersion()) {} + DecimalQty( + char *buffer, + const std::uint64_t bufferLength) : + DecimalQty(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } - DecimalQty &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = DecimalQty(buffer, offset, bufferLength, actingVersion); - } + DecimalQty &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = DecimalQty(buffer, offset, bufferLength, actingVersion); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - encodedLength() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t encodedLength() SBE_NOEXCEPT + { + return 4; + } - 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)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mantissaSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t mantissaId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool mantissaInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mantissaSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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); + } - DecimalQty &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; - } + DecimalQty &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 "constant"; - default: - return ""; - } - } + SBE_NODISCARD static const char *exponentMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::PRESENCE: return "constant"; + 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 0; + } + + 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 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)-4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::int8_t exponent() SBE_NOEXCEPT + { + return static_cast(-4); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, DecimalQty writer) { - builder << '{'; - builder << R"("mantissa": )"; - builder << +writer.mantissa(); +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, DecimalQty writer) +{ + builder << '{'; + builder << R"("mantissa": )"; + builder << +writer.mantissa(); - builder << '}'; + builder << '}'; + + return builder; +} - return builder; - } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/EventType.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/EventType.h index 8f236e274..5b0cce853 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/EventType.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/EventType.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,49 +86,51 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class EventType { - public: - enum Value { - Activation = (std::uint8_t)5, - LastEligibleTradeDate = (std::uint8_t)7, - NULL_VALUE = (std::uint8_t)255 - }; +class EventType +{ +public: + enum Value + { + Activation = static_cast(5), + LastEligibleTradeDate = static_cast(7), + NULL_VALUE = static_cast(255) + }; - static EventType::Value get(const std::uint8_t value) { - switch (value) { - case 5: - return Activation; - case 7: - return LastEligibleTradeDate; - case 255: - return NULL_VALUE; - } + static EventType::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(5): return Activation; + case static_cast(7): return LastEligibleTradeDate; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum EventType [E103]"); - } + throw std::runtime_error("unknown value for enum EventType [E103]"); + } - static const char *c_str(const EventType::Value value) { - switch (value) { - case Activation: - return "Activation"; - case LastEligibleTradeDate: - return "LastEligibleTradeDate"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const EventType::Value value) + { + switch (value) + { + case Activation: return "Activation"; + case LastEligibleTradeDate: return "LastEligibleTradeDate"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum EventType [E103]:"); - } + throw std::runtime_error("unknown value for enum EventType [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, EventType::Value m) { - return os << EventType::c_str(m); - } + template + friend std::basic_ostream& operator << ( + std::basic_ostream& os, EventType::Value m) + { + return os << EventType::c_str(m); + } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/FLOAT.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/FLOAT.h index 02626b478..1692bcbfa 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/FLOAT.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/FLOAT.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,210 +86,263 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class FLOAT { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; +class FLOAT +{ +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; + }; - FLOAT() = default; + FLOAT() = default; - FLOAT( - 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]"); - } - } + FLOAT( + 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]"); + } + } - FLOAT( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : FLOAT(buffer, 0, bufferLength, actingVersion) {} + FLOAT( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + FLOAT(buffer, 0, bufferLength, actingVersion) + { + } - FLOAT(char *buffer, const std::uint64_t bufferLength) - : FLOAT(buffer, 0, bufferLength, sbeSchemaVersion()) {} + FLOAT( + char *buffer, + const std::uint64_t bufferLength) : + FLOAT(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } - FLOAT &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = FLOAT(buffer, offset, bufferLength, actingVersion); - } + FLOAT &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = FLOAT(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)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mantissaSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t mantissaId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool mantissaInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mantissaSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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); + } - FLOAT &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; - } + FLOAT &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 ""; + } + } - 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 0; + } + + 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)-7; - } + SBE_NODISCARD static SBE_CONSTEXPR std::int8_t exponent() SBE_NOEXCEPT + { + return static_cast(-7); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, FLOAT writer) { - builder << '{'; - builder << R"("mantissa": )"; - builder << +writer.mantissa(); +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, FLOAT writer) +{ + builder << '{'; + builder << R"("mantissa": )"; + builder << +writer.mantissa(); - builder << '}'; + builder << '}'; + + return builder; +} - return builder; - } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/GroupSize.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/GroupSize.h index d0b3a8bd8..e7f9583f3 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/GroupSize.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/GroupSize.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,222 +86,276 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -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)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - blockLengthSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t blockLengthId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool blockLengthInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t blockLengthSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - numInGroupSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t numInGroupId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool numInGroupInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t numInGroupSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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 mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/GroupSize8Byte.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/GroupSize8Byte.h index a553bf4c8..967a6d0d8 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/GroupSize8Byte.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/GroupSize8Byte.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,223 +86,276 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class GroupSize8Byte { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; +class GroupSize8Byte +{ +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; + }; - GroupSize8Byte() = default; + GroupSize8Byte() = default; - GroupSize8Byte( - 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]"); - } - } + GroupSize8Byte( + 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]"); + } + } - GroupSize8Byte( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : GroupSize8Byte(buffer, 0, bufferLength, actingVersion) {} + GroupSize8Byte( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + GroupSize8Byte(buffer, 0, bufferLength, actingVersion) + { + } - GroupSize8Byte(char *buffer, const std::uint64_t bufferLength) - : GroupSize8Byte(buffer, 0, bufferLength, sbeSchemaVersion()) {} + GroupSize8Byte( + char *buffer, + const std::uint64_t bufferLength) : + GroupSize8Byte(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } - GroupSize8Byte &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = - GroupSize8Byte(buffer, offset, bufferLength, actingVersion); - } + GroupSize8Byte &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = GroupSize8Byte(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)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - blockLengthSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t blockLengthId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool blockLengthInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t blockLengthSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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); + } - GroupSize8Byte &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; - } + GroupSize8Byte &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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - numInGroupSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t numInGroupId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool numInGroupInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t numInGroupSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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 7; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t numInGroupEncodingOffset() SBE_NOEXCEPT + { + return 7; + } - 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 + 7, 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 + 7, sizeof(std::uint8_t)); + return (val); + } - GroupSize8Byte &numInGroup(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 7, &val, sizeof(std::uint8_t)); - return *this; - } + GroupSize8Byte &numInGroup(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 7, &val, sizeof(std::uint8_t)); + return *this; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, GroupSize8Byte writer) { - builder << '{'; - builder << R"("blockLength": )"; - builder << +writer.blockLength(); +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, GroupSize8Byte 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 mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/HaltReason.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/HaltReason.h index b3433f540..67989d04e 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/HaltReason.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/HaltReason.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,74 +86,66 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class HaltReason { - public: - enum Value { - GroupSchedule = (std::uint8_t)0, - SurveillanceIntervention = (std::uint8_t)1, - MarketEvent = (std::uint8_t)2, - InstrumentActivation = (std::uint8_t)3, - InstrumentExpiration = (std::uint8_t)4, - Unknown = (std::uint8_t)5, - RecoveryInProcess = (std::uint8_t)6, - NULL_VALUE = (std::uint8_t)255 - }; +class HaltReason +{ +public: + enum Value + { + GroupSchedule = static_cast(0), + SurveillanceIntervention = static_cast(1), + MarketEvent = static_cast(2), + InstrumentActivation = static_cast(3), + InstrumentExpiration = static_cast(4), + Unknown = static_cast(5), + RecoveryInProcess = static_cast(6), + NULL_VALUE = static_cast(255) + }; - static HaltReason::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return GroupSchedule; - case 1: - return SurveillanceIntervention; - case 2: - return MarketEvent; - case 3: - return InstrumentActivation; - case 4: - return InstrumentExpiration; - case 5: - return Unknown; - case 6: - return RecoveryInProcess; - case 255: - return NULL_VALUE; - } + static HaltReason::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return GroupSchedule; + case static_cast(1): return SurveillanceIntervention; + case static_cast(2): return MarketEvent; + case static_cast(3): return InstrumentActivation; + case static_cast(4): return InstrumentExpiration; + case static_cast(5): return Unknown; + case static_cast(6): return RecoveryInProcess; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum HaltReason [E103]"); - } + throw std::runtime_error("unknown value for enum HaltReason [E103]"); + } - static const char *c_str(const HaltReason::Value value) { - switch (value) { - case GroupSchedule: - return "GroupSchedule"; - case SurveillanceIntervention: - return "SurveillanceIntervention"; - case MarketEvent: - return "MarketEvent"; - case InstrumentActivation: - return "InstrumentActivation"; - case InstrumentExpiration: - return "InstrumentExpiration"; - case Unknown: - return "Unknown"; - case RecoveryInProcess: - return "RecoveryInProcess"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const HaltReason::Value value) + { + switch (value) + { + case GroupSchedule: return "GroupSchedule"; + case SurveillanceIntervention: return "SurveillanceIntervention"; + case MarketEvent: return "MarketEvent"; + case InstrumentActivation: return "InstrumentActivation"; + case InstrumentExpiration: return "InstrumentExpiration"; + case Unknown: return "Unknown"; + case RecoveryInProcess: return "RecoveryInProcess"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum HaltReason [E103]:"); - } + throw std::runtime_error("unknown value for enum HaltReason [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, HaltReason::Value m) { - return os << HaltReason::c_str(m); - } + template + friend std::basic_ostream& operator << ( + std::basic_ostream& os, HaltReason::Value m) + { + return os << HaltReason::c_str(m); + } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/InstAttribValue.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/InstAttribValue.h index 9bbc77ddd..e9b8007c0 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/InstAttribValue.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/InstAttribValue.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,893 +86,928 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class InstAttribValue { - 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 }; - - 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; - }; - - InstAttribValue() = default; - - InstAttribValue( - 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 + 4) > m_bufferLength), false)) { - throw std::runtime_error("buffer too short for flyweight [E107]"); - } - } - - InstAttribValue( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : InstAttribValue(buffer, 0, bufferLength, actingVersion) {} - - InstAttribValue(char *buffer, const std::uint64_t bufferLength) - : InstAttribValue(buffer, 0, bufferLength, sbeSchemaVersion()) {} - - InstAttribValue &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = - InstAttribValue(buffer, offset, bufferLength, actingVersion); - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - encodedLength() SBE_NOEXCEPT { - return 4; - } - - 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 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 SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } - - InstAttribValue &clear() { - std::uint32_t zero = 0; - std::memcpy(m_buffer + m_offset, &zero, sizeof(std::uint32_t)); - return *this; - } - - SBE_NODISCARD bool isEmpty() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return 0 == val; - } - - SBE_NODISCARD std::uint32_t rawValue() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return val; - } - - InstAttribValue &rawValue(std::uint32_t value) { - std::memcpy(m_buffer + m_offset, &value, sizeof(std::uint32_t)); - return *this; - } - - static bool electronicMatchEligible(const std::uint32_t bits) { - return (bits & (1u << 0u)) != 0; - } - - static std::uint32_t - electronicMatchEligible(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 0u)) - : static_cast(bits & ~(1u << 0u)); - } - - SBE_NODISCARD bool electronicMatchEligible() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 0u)) != 0; - } - - InstAttribValue &electronicMatchEligible(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 0u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 0u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool orderCrossEligible(const std::uint32_t bits) { - return (bits & (1u << 1u)) != 0; - } - - static std::uint32_t - orderCrossEligible(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 1u)) - : static_cast(bits & ~(1u << 1u)); - } - - SBE_NODISCARD bool orderCrossEligible() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 1u)) != 0; - } - - InstAttribValue &orderCrossEligible(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 1u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 1u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool blockTradeEligible(const std::uint32_t bits) { - return (bits & (1u << 2u)) != 0; - } - - static std::uint32_t - blockTradeEligible(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 2u)) - : static_cast(bits & ~(1u << 2u)); - } - - SBE_NODISCARD bool blockTradeEligible() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 2u)) != 0; - } - - InstAttribValue &blockTradeEligible(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 2u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 2u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool eFPEligible(const std::uint32_t bits) { - return (bits & (1u << 3u)) != 0; - } - - static std::uint32_t - eFPEligible(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 3u)) - : static_cast(bits & ~(1u << 3u)); - } - - SBE_NODISCARD bool eFPEligible() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 3u)) != 0; - } - - InstAttribValue &eFPEligible(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 3u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 3u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool eBFEligible(const std::uint32_t bits) { - return (bits & (1u << 4u)) != 0; - } - - static std::uint32_t - eBFEligible(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 4u)) - : static_cast(bits & ~(1u << 4u)); - } - - SBE_NODISCARD bool eBFEligible() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 4u)) != 0; - } - - InstAttribValue &eBFEligible(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 4u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 4u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool eFSEligible(const std::uint32_t bits) { - return (bits & (1u << 5u)) != 0; - } - - static std::uint32_t - eFSEligible(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 5u)) - : static_cast(bits & ~(1u << 5u)); - } - - SBE_NODISCARD bool eFSEligible() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 5u)) != 0; - } - - InstAttribValue &eFSEligible(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 5u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 5u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool eFREligible(const std::uint32_t bits) { - return (bits & (1u << 6u)) != 0; - } - - static std::uint32_t - eFREligible(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 6u)) - : static_cast(bits & ~(1u << 6u)); - } - - SBE_NODISCARD bool eFREligible() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 6u)) != 0; - } - - InstAttribValue &eFREligible(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 6u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 6u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool oTCEligible(const std::uint32_t bits) { - return (bits & (1u << 7u)) != 0; - } - - static std::uint32_t - oTCEligible(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 7u)) - : static_cast(bits & ~(1u << 7u)); - } - - SBE_NODISCARD bool oTCEligible() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 7u)) != 0; - } - - InstAttribValue &oTCEligible(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 7u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 7u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool iLinkIndicativeMassQuotingEligible(const std::uint32_t bits) { - return (bits & (1u << 8u)) != 0; - } - - static std::uint32_t iLinkIndicativeMassQuotingEligible( - const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 8u)) - : static_cast(bits & ~(1u << 8u)); - } - - SBE_NODISCARD bool iLinkIndicativeMassQuotingEligible() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 8u)) != 0; - } - - InstAttribValue &iLinkIndicativeMassQuotingEligible(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 8u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 8u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool negativeStrikeEligible(const std::uint32_t bits) { - return (bits & (1u << 9u)) != 0; - } - - static std::uint32_t - negativeStrikeEligible(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 9u)) - : static_cast(bits & ~(1u << 9u)); - } - - SBE_NODISCARD bool negativeStrikeEligible() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 9u)) != 0; - } - - InstAttribValue &negativeStrikeEligible(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 9u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 9u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool negativePriceOutrightEligible(const std::uint32_t bits) { - return (bits & (1u << 10u)) != 0; - } - - static std::uint32_t - negativePriceOutrightEligible(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 10u)) - : static_cast(bits & ~(1u << 10u)); - } - - SBE_NODISCARD bool negativePriceOutrightEligible() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 10u)) != 0; - } - - InstAttribValue &negativePriceOutrightEligible(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 10u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 10u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool isFractional(const std::uint32_t bits) { - return (bits & (1u << 11u)) != 0; - } - - static std::uint32_t - isFractional(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 11u)) - : static_cast(bits & ~(1u << 11u)); - } - - SBE_NODISCARD bool isFractional() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 11u)) != 0; - } - - InstAttribValue &isFractional(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 11u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 11u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool volatilityQuotedOption(const std::uint32_t bits) { - return (bits & (1u << 12u)) != 0; - } - - static std::uint32_t - volatilityQuotedOption(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 12u)) - : static_cast(bits & ~(1u << 12u)); - } - - SBE_NODISCARD bool volatilityQuotedOption() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 12u)) != 0; - } - - InstAttribValue &volatilityQuotedOption(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 12u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 12u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool rFQCrossEligible(const std::uint32_t bits) { - return (bits & (1u << 13u)) != 0; - } - - static std::uint32_t - rFQCrossEligible(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 13u)) - : static_cast(bits & ~(1u << 13u)); - } - - SBE_NODISCARD bool rFQCrossEligible() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 13u)) != 0; - } - - InstAttribValue &rFQCrossEligible(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 13u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 13u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool zeroPriceOutrightEligible(const std::uint32_t bits) { - return (bits & (1u << 14u)) != 0; - } - - static std::uint32_t - zeroPriceOutrightEligible(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 14u)) - : static_cast(bits & ~(1u << 14u)); - } - - SBE_NODISCARD bool zeroPriceOutrightEligible() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 14u)) != 0; - } - - InstAttribValue &zeroPriceOutrightEligible(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 14u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 14u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool decayingProductEligibility(const std::uint32_t bits) { - return (bits & (1u << 15u)) != 0; - } - - static std::uint32_t - decayingProductEligibility(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 15u)) - : static_cast(bits & ~(1u << 15u)); - } - - SBE_NODISCARD bool decayingProductEligibility() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 15u)) != 0; - } - - InstAttribValue &decayingProductEligibility(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 15u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 15u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool variableProductEligibility(const std::uint32_t bits) { - return (bits & (1u << 16u)) != 0; - } - - static std::uint32_t - variableProductEligibility(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 16u)) - : static_cast(bits & ~(1u << 16u)); - } - - SBE_NODISCARD bool variableProductEligibility() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 16u)) != 0; - } - - InstAttribValue &variableProductEligibility(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 16u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 16u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool dailyProductEligibility(const std::uint32_t bits) { - return (bits & (1u << 17u)) != 0; - } - - static std::uint32_t - dailyProductEligibility(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 17u)) - : static_cast(bits & ~(1u << 17u)); - } - - SBE_NODISCARD bool dailyProductEligibility() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 17u)) != 0; - } - - InstAttribValue &dailyProductEligibility(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 17u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 17u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool gTOrdersEligibility(const std::uint32_t bits) { - return (bits & (1u << 18u)) != 0; - } - - static std::uint32_t - gTOrdersEligibility(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 18u)) - : static_cast(bits & ~(1u << 18u)); - } - - SBE_NODISCARD bool gTOrdersEligibility() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 18u)) != 0; - } - - InstAttribValue &gTOrdersEligibility(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 18u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 18u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool impliedMatchingEligibility(const std::uint32_t bits) { - return (bits & (1u << 19u)) != 0; - } - - static std::uint32_t - impliedMatchingEligibility(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 19u)) - : static_cast(bits & ~(1u << 19u)); - } - - SBE_NODISCARD bool impliedMatchingEligibility() const { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 19u)) != 0; - } - - InstAttribValue &impliedMatchingEligibility(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 19u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 19u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool triangulationEligible(const std::uint32_t bits) { - return (bits & (1u << 20u)) != 0; - } - - static std::uint32_t - triangulationEligible(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 20u)) - : static_cast(bits & ~(1u << 20u)); - } - - SBE_NODISCARD bool triangulationEligible() const { - if (m_actingVersion < 9) { - return false; - } - - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 20u)) != 0; - } - - InstAttribValue &triangulationEligible(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 20u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 20u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - static bool variableCabEligible(const std::uint32_t bits) { - return (bits & (1u << 21u)) != 0; - } - - static std::uint32_t - variableCabEligible(const std::uint32_t bits, const bool value) { - return value ? static_cast(bits | (1u << 21u)) - : static_cast(bits & ~(1u << 21u)); - } - - SBE_NODISCARD bool variableCabEligible() const { - if (m_actingVersion < 9) { - return false; - } - - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); - return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (1u << 21u)) != 0; - } - - InstAttribValue &variableCabEligible(const bool value) { - std::uint32_t bits; - std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); - bits = SBE_LITTLE_ENDIAN_ENCODE_32( - value ? static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (1u << 21u)) - : static_cast( - SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(1u << 21u))); - std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, InstAttribValue writer) { - builder << '['; - bool atLeastOne = false; - if (writer.electronicMatchEligible()) { - builder << R"("electronicMatchEligible")"; - atLeastOne = true; - } - if (writer.orderCrossEligible()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("orderCrossEligible")"; - atLeastOne = true; - } - if (writer.blockTradeEligible()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("blockTradeEligible")"; - atLeastOne = true; - } - if (writer.eFPEligible()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("eFPEligible")"; - atLeastOne = true; - } - if (writer.eBFEligible()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("eBFEligible")"; - atLeastOne = true; - } - if (writer.eFSEligible()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("eFSEligible")"; - atLeastOne = true; - } - if (writer.eFREligible()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("eFREligible")"; - atLeastOne = true; - } - if (writer.oTCEligible()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("oTCEligible")"; - atLeastOne = true; - } - if (writer.iLinkIndicativeMassQuotingEligible()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("iLinkIndicativeMassQuotingEligible")"; - atLeastOne = true; - } - if (writer.negativeStrikeEligible()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("negativeStrikeEligible")"; - atLeastOne = true; - } - if (writer.negativePriceOutrightEligible()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("negativePriceOutrightEligible")"; - atLeastOne = true; - } - if (writer.isFractional()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("isFractional")"; - atLeastOne = true; - } - if (writer.volatilityQuotedOption()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("volatilityQuotedOption")"; - atLeastOne = true; - } - if (writer.rFQCrossEligible()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("rFQCrossEligible")"; - atLeastOne = true; - } - if (writer.zeroPriceOutrightEligible()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("zeroPriceOutrightEligible")"; - atLeastOne = true; - } - if (writer.decayingProductEligibility()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("decayingProductEligibility")"; - atLeastOne = true; - } - if (writer.variableProductEligibility()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("variableProductEligibility")"; - atLeastOne = true; - } - if (writer.dailyProductEligibility()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("dailyProductEligibility")"; - atLeastOne = true; - } - if (writer.gTOrdersEligibility()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("gTOrdersEligibility")"; - atLeastOne = true; - } - if (writer.impliedMatchingEligibility()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("impliedMatchingEligibility")"; - atLeastOne = true; - } - if (writer.triangulationEligible()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("triangulationEligible")"; - atLeastOne = true; - } - if (writer.variableCabEligible()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("variableCabEligible")"; - } - builder << ']'; - return builder; - } +class InstAttribValue +{ +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 + }; + + 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; + }; + + InstAttribValue() = default; + + InstAttribValue( + 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 + 4) > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short for flyweight [E107]"); + } + } + + InstAttribValue( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + InstAttribValue(buffer, 0, bufferLength, actingVersion) + { + } + + InstAttribValue( + char *buffer, + const std::uint64_t bufferLength) : + InstAttribValue(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } + + InstAttribValue &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = InstAttribValue(buffer, offset, bufferLength, actingVersion); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t encodedLength() SBE_NOEXCEPT + { + return 4; + } + + 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 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 SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } + + InstAttribValue &clear() + { + std::uint32_t zero = 0; + std::memcpy(m_buffer + m_offset, &zero, sizeof(std::uint32_t)); + return *this; + } + + SBE_NODISCARD bool isEmpty() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return 0 == val; + } + + SBE_NODISCARD std::uint32_t rawValue() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return val; + } + + InstAttribValue &rawValue(std::uint32_t value) + { + std::memcpy(m_buffer + m_offset, &value, sizeof(std::uint32_t)); + return *this; + } + + static bool electronicMatchEligible(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 0u)) != 0; + } + + static std::uint32_t electronicMatchEligible(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 0u)) : static_cast(bits & ~(UINT32_C(0x1) << 0u)); + } + + SBE_NODISCARD bool electronicMatchEligible() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 0u)) != 0; + } + + InstAttribValue &electronicMatchEligible(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 0u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 0u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool orderCrossEligible(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 1u)) != 0; + } + + static std::uint32_t orderCrossEligible(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 1u)) : static_cast(bits & ~(UINT32_C(0x1) << 1u)); + } + + SBE_NODISCARD bool orderCrossEligible() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 1u)) != 0; + } + + InstAttribValue &orderCrossEligible(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 1u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 1u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool blockTradeEligible(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 2u)) != 0; + } + + static std::uint32_t blockTradeEligible(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 2u)) : static_cast(bits & ~(UINT32_C(0x1) << 2u)); + } + + SBE_NODISCARD bool blockTradeEligible() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 2u)) != 0; + } + + InstAttribValue &blockTradeEligible(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 2u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 2u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool eFPEligible(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 3u)) != 0; + } + + static std::uint32_t eFPEligible(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 3u)) : static_cast(bits & ~(UINT32_C(0x1) << 3u)); + } + + SBE_NODISCARD bool eFPEligible() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 3u)) != 0; + } + + InstAttribValue &eFPEligible(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 3u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 3u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool eBFEligible(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 4u)) != 0; + } + + static std::uint32_t eBFEligible(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 4u)) : static_cast(bits & ~(UINT32_C(0x1) << 4u)); + } + + SBE_NODISCARD bool eBFEligible() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 4u)) != 0; + } + + InstAttribValue &eBFEligible(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 4u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 4u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool eFSEligible(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 5u)) != 0; + } + + static std::uint32_t eFSEligible(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 5u)) : static_cast(bits & ~(UINT32_C(0x1) << 5u)); + } + + SBE_NODISCARD bool eFSEligible() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 5u)) != 0; + } + + InstAttribValue &eFSEligible(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 5u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 5u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool eFREligible(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 6u)) != 0; + } + + static std::uint32_t eFREligible(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 6u)) : static_cast(bits & ~(UINT32_C(0x1) << 6u)); + } + + SBE_NODISCARD bool eFREligible() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 6u)) != 0; + } + + InstAttribValue &eFREligible(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 6u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 6u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool oTCEligible(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 7u)) != 0; + } + + static std::uint32_t oTCEligible(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 7u)) : static_cast(bits & ~(UINT32_C(0x1) << 7u)); + } + + SBE_NODISCARD bool oTCEligible() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 7u)) != 0; + } + + InstAttribValue &oTCEligible(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 7u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 7u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool iLinkIndicativeMassQuotingEligible(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 8u)) != 0; + } + + static std::uint32_t iLinkIndicativeMassQuotingEligible(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 8u)) : static_cast(bits & ~(UINT32_C(0x1) << 8u)); + } + + SBE_NODISCARD bool iLinkIndicativeMassQuotingEligible() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 8u)) != 0; + } + + InstAttribValue &iLinkIndicativeMassQuotingEligible(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 8u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 8u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool negativeStrikeEligible(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 9u)) != 0; + } + + static std::uint32_t negativeStrikeEligible(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 9u)) : static_cast(bits & ~(UINT32_C(0x1) << 9u)); + } + + SBE_NODISCARD bool negativeStrikeEligible() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 9u)) != 0; + } + + InstAttribValue &negativeStrikeEligible(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 9u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 9u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool negativePriceOutrightEligible(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 10u)) != 0; + } + + static std::uint32_t negativePriceOutrightEligible(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 10u)) : static_cast(bits & ~(UINT32_C(0x1) << 10u)); + } + + SBE_NODISCARD bool negativePriceOutrightEligible() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 10u)) != 0; + } + + InstAttribValue &negativePriceOutrightEligible(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 10u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 10u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool isFractional(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 11u)) != 0; + } + + static std::uint32_t isFractional(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 11u)) : static_cast(bits & ~(UINT32_C(0x1) << 11u)); + } + + SBE_NODISCARD bool isFractional() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 11u)) != 0; + } + + InstAttribValue &isFractional(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 11u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 11u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool volatilityQuotedOption(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 12u)) != 0; + } + + static std::uint32_t volatilityQuotedOption(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 12u)) : static_cast(bits & ~(UINT32_C(0x1) << 12u)); + } + + SBE_NODISCARD bool volatilityQuotedOption() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 12u)) != 0; + } + + InstAttribValue &volatilityQuotedOption(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 12u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 12u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool rFQCrossEligible(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 13u)) != 0; + } + + static std::uint32_t rFQCrossEligible(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 13u)) : static_cast(bits & ~(UINT32_C(0x1) << 13u)); + } + + SBE_NODISCARD bool rFQCrossEligible() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 13u)) != 0; + } + + InstAttribValue &rFQCrossEligible(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 13u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 13u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool zeroPriceOutrightEligible(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 14u)) != 0; + } + + static std::uint32_t zeroPriceOutrightEligible(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 14u)) : static_cast(bits & ~(UINT32_C(0x1) << 14u)); + } + + SBE_NODISCARD bool zeroPriceOutrightEligible() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 14u)) != 0; + } + + InstAttribValue &zeroPriceOutrightEligible(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 14u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 14u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool decayingProductEligibility(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 15u)) != 0; + } + + static std::uint32_t decayingProductEligibility(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 15u)) : static_cast(bits & ~(UINT32_C(0x1) << 15u)); + } + + SBE_NODISCARD bool decayingProductEligibility() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 15u)) != 0; + } + + InstAttribValue &decayingProductEligibility(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 15u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 15u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool variableProductEligibility(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 16u)) != 0; + } + + static std::uint32_t variableProductEligibility(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 16u)) : static_cast(bits & ~(UINT32_C(0x1) << 16u)); + } + + SBE_NODISCARD bool variableProductEligibility() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 16u)) != 0; + } + + InstAttribValue &variableProductEligibility(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 16u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 16u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool dailyProductEligibility(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 17u)) != 0; + } + + static std::uint32_t dailyProductEligibility(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 17u)) : static_cast(bits & ~(UINT32_C(0x1) << 17u)); + } + + SBE_NODISCARD bool dailyProductEligibility() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 17u)) != 0; + } + + InstAttribValue &dailyProductEligibility(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 17u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 17u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool gTOrdersEligibility(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 18u)) != 0; + } + + static std::uint32_t gTOrdersEligibility(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 18u)) : static_cast(bits & ~(UINT32_C(0x1) << 18u)); + } + + SBE_NODISCARD bool gTOrdersEligibility() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 18u)) != 0; + } + + InstAttribValue &gTOrdersEligibility(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 18u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 18u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool impliedMatchingEligibility(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 19u)) != 0; + } + + static std::uint32_t impliedMatchingEligibility(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 19u)) : static_cast(bits & ~(UINT32_C(0x1) << 19u)); + } + + SBE_NODISCARD bool impliedMatchingEligibility() const + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 19u)) != 0; + } + + InstAttribValue &impliedMatchingEligibility(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 19u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 19u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool triangulationEligible(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 20u)) != 0; + } + + static std::uint32_t triangulationEligible(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 20u)) : static_cast(bits & ~(UINT32_C(0x1) << 20u)); + } + + SBE_NODISCARD bool triangulationEligible() const + { + if (m_actingVersion < 9) + { + return false; + } + + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 20u)) != 0; + } + + InstAttribValue &triangulationEligible(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 20u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 20u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + static bool variableCabEligible(const std::uint32_t bits) + { + return (bits & (UINT32_C(0x1) << 21u)) != 0; + } + + static std::uint32_t variableCabEligible(const std::uint32_t bits, const bool value) + { + return value ? static_cast(bits | (UINT32_C(0x1) << 21u)) : static_cast(bits & ~(UINT32_C(0x1) << 21u)); + } + + SBE_NODISCARD bool variableCabEligible() const + { + if (m_actingVersion < 9) + { + return false; + } + + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint32_t)); + return (SBE_LITTLE_ENDIAN_ENCODE_32(val) & (UINT32_C(0x1) << 21u)) != 0; + } + + InstAttribValue &variableCabEligible(const bool value) + { + std::uint32_t bits; + std::memcpy(&bits, m_buffer + m_offset, sizeof(std::uint32_t)); + bits = SBE_LITTLE_ENDIAN_ENCODE_32(value ? static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) | (UINT32_C(0x1) << 21u)) : static_cast(SBE_LITTLE_ENDIAN_ENCODE_32(bits) & ~(UINT32_C(0x1) << 21u))); + std::memcpy(m_buffer + m_offset, &bits, sizeof(std::uint32_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, InstAttribValue writer) + { + builder << '['; + bool atLeastOne = false; + if (writer.electronicMatchEligible()) + { + builder << R"("electronicMatchEligible")"; + atLeastOne = true; + } + if (writer.orderCrossEligible()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("orderCrossEligible")"; + atLeastOne = true; + } + if (writer.blockTradeEligible()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("blockTradeEligible")"; + atLeastOne = true; + } + if (writer.eFPEligible()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("eFPEligible")"; + atLeastOne = true; + } + if (writer.eBFEligible()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("eBFEligible")"; + atLeastOne = true; + } + if (writer.eFSEligible()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("eFSEligible")"; + atLeastOne = true; + } + if (writer.eFREligible()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("eFREligible")"; + atLeastOne = true; + } + if (writer.oTCEligible()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("oTCEligible")"; + atLeastOne = true; + } + if (writer.iLinkIndicativeMassQuotingEligible()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("iLinkIndicativeMassQuotingEligible")"; + atLeastOne = true; + } + if (writer.negativeStrikeEligible()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("negativeStrikeEligible")"; + atLeastOne = true; + } + if (writer.negativePriceOutrightEligible()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("negativePriceOutrightEligible")"; + atLeastOne = true; + } + if (writer.isFractional()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("isFractional")"; + atLeastOne = true; + } + if (writer.volatilityQuotedOption()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("volatilityQuotedOption")"; + atLeastOne = true; + } + if (writer.rFQCrossEligible()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("rFQCrossEligible")"; + atLeastOne = true; + } + if (writer.zeroPriceOutrightEligible()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("zeroPriceOutrightEligible")"; + atLeastOne = true; + } + if (writer.decayingProductEligibility()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("decayingProductEligibility")"; + atLeastOne = true; + } + if (writer.variableProductEligibility()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("variableProductEligibility")"; + atLeastOne = true; + } + if (writer.dailyProductEligibility()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("dailyProductEligibility")"; + atLeastOne = true; + } + if (writer.gTOrdersEligibility()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("gTOrdersEligibility")"; + atLeastOne = true; + } + if (writer.impliedMatchingEligibility()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("impliedMatchingEligibility")"; + atLeastOne = true; + } + if (writer.triangulationEligible()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("triangulationEligible")"; + atLeastOne = true; + } + if (writer.variableCabEligible()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("variableCabEligible")"; + } + builder << ']'; + return builder; + } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/LegSide.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/LegSide.h index 128b6ec03..755014faa 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/LegSide.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/LegSide.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,49 +86,51 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class LegSide { - public: - enum Value { - BuySide = (std::uint8_t)1, - SellSide = (std::uint8_t)2, - NULL_VALUE = (std::uint8_t)255 - }; +class LegSide +{ +public: + enum Value + { + BuySide = static_cast(1), + SellSide = static_cast(2), + NULL_VALUE = static_cast(255) + }; - static LegSide::Value get(const std::uint8_t value) { - switch (value) { - case 1: - return BuySide; - case 2: - return SellSide; - case 255: - return NULL_VALUE; - } + static LegSide::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(1): return BuySide; + case static_cast(2): return SellSide; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum LegSide [E103]"); - } + throw std::runtime_error("unknown value for enum LegSide [E103]"); + } - static const char *c_str(const LegSide::Value value) { - switch (value) { - case BuySide: - return "BuySide"; - case SellSide: - return "SellSide"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const LegSide::Value value) + { + switch (value) + { + case BuySide: return "BuySide"; + case SellSide: return "SellSide"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum LegSide [E103]:"); - } + throw std::runtime_error("unknown value for enum LegSide [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, LegSide::Value m) { - return os << LegSide::c_str(m); - } + template + friend std::basic_ostream& operator << ( + std::basic_ostream& os, LegSide::Value m) + { + return os << LegSide::c_str(m); + } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDEntryType.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDEntryType.h index 881a3f9be..7df78d7a6 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDEntryType.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDEntryType.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,124 +86,96 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class MDEntryType { - public: - enum Value { - Bid = (char)48, - Offer = (char)49, - Trade = (char)50, - OpenPrice = (char)52, - SettlementPrice = (char)54, - TradingSessionHighPrice = (char)55, - TradingSessionLowPrice = (char)56, - ClearedVolume = (char)66, - OpenInterest = (char)67, - ImpliedBid = (char)69, - ImpliedOffer = (char)70, - BookReset = (char)74, - SessionHighBid = (char)78, - SessionLowOffer = (char)79, - FixingPrice = (char)87, - ElectronicVolume = (char)101, - ThresholdLimitsandPriceBandVariation = (char)103, - NULL_VALUE = (char)0 - }; +class MDEntryType +{ +public: + enum Value + { + Bid = static_cast(48), + Offer = static_cast(49), + Trade = static_cast(50), + OpenPrice = static_cast(52), + SettlementPrice = static_cast(54), + TradingSessionHighPrice = static_cast(55), + TradingSessionLowPrice = static_cast(56), + ClearedVolume = static_cast(66), + OpenInterest = static_cast(67), + ImpliedBid = static_cast(69), + ImpliedOffer = static_cast(70), + BookReset = static_cast(74), + SessionHighBid = static_cast(78), + SessionLowOffer = static_cast(79), + FixingPrice = static_cast(87), + ElectronicVolume = static_cast(101), + ThresholdLimitsandPriceBandVariation = static_cast(103), + NULL_VALUE = static_cast(0) + }; - static MDEntryType::Value get(const char value) { - switch (value) { - case 48: - return Bid; - case 49: - return Offer; - case 50: - return Trade; - case 52: - return OpenPrice; - case 54: - return SettlementPrice; - case 55: - return TradingSessionHighPrice; - case 56: - return TradingSessionLowPrice; - case 66: - return ClearedVolume; - case 67: - return OpenInterest; - case 69: - return ImpliedBid; - case 70: - return ImpliedOffer; - case 74: - return BookReset; - case 78: - return SessionHighBid; - case 79: - return SessionLowOffer; - case 87: - return FixingPrice; - case 101: - return ElectronicVolume; - case 103: - return ThresholdLimitsandPriceBandVariation; - case 0: - return NULL_VALUE; - } + static MDEntryType::Value get(const char value) + { + switch (value) + { + case static_cast(48): return Bid; + case static_cast(49): return Offer; + case static_cast(50): return Trade; + case static_cast(52): return OpenPrice; + case static_cast(54): return SettlementPrice; + case static_cast(55): return TradingSessionHighPrice; + case static_cast(56): return TradingSessionLowPrice; + case static_cast(66): return ClearedVolume; + case static_cast(67): return OpenInterest; + case static_cast(69): return ImpliedBid; + case static_cast(70): return ImpliedOffer; + case static_cast(74): return BookReset; + case static_cast(78): return SessionHighBid; + case static_cast(79): return SessionLowOffer; + case static_cast(87): return FixingPrice; + case static_cast(101): return ElectronicVolume; + case static_cast(103): return ThresholdLimitsandPriceBandVariation; + case static_cast(0): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum MDEntryType [E103]"); - } + throw std::runtime_error("unknown value for enum MDEntryType [E103]"); + } - static const char *c_str(const MDEntryType::Value value) { - switch (value) { - case Bid: - return "Bid"; - case Offer: - return "Offer"; - case Trade: - return "Trade"; - case OpenPrice: - return "OpenPrice"; - case SettlementPrice: - return "SettlementPrice"; - case TradingSessionHighPrice: - return "TradingSessionHighPrice"; - case TradingSessionLowPrice: - return "TradingSessionLowPrice"; - case ClearedVolume: - return "ClearedVolume"; - case OpenInterest: - return "OpenInterest"; - case ImpliedBid: - return "ImpliedBid"; - case ImpliedOffer: - return "ImpliedOffer"; - case BookReset: - return "BookReset"; - case SessionHighBid: - return "SessionHighBid"; - case SessionLowOffer: - return "SessionLowOffer"; - case FixingPrice: - return "FixingPrice"; - case ElectronicVolume: - return "ElectronicVolume"; - case ThresholdLimitsandPriceBandVariation: - return "ThresholdLimitsandPriceBandVariation"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const MDEntryType::Value value) + { + switch (value) + { + case Bid: return "Bid"; + case Offer: return "Offer"; + case Trade: return "Trade"; + case OpenPrice: return "OpenPrice"; + case SettlementPrice: return "SettlementPrice"; + case TradingSessionHighPrice: return "TradingSessionHighPrice"; + case TradingSessionLowPrice: return "TradingSessionLowPrice"; + case ClearedVolume: return "ClearedVolume"; + case OpenInterest: return "OpenInterest"; + case ImpliedBid: return "ImpliedBid"; + case ImpliedOffer: return "ImpliedOffer"; + case BookReset: return "BookReset"; + case SessionHighBid: return "SessionHighBid"; + case SessionLowOffer: return "SessionLowOffer"; + case FixingPrice: return "FixingPrice"; + case ElectronicVolume: return "ElectronicVolume"; + case ThresholdLimitsandPriceBandVariation: return "ThresholdLimitsandPriceBandVariation"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum MDEntryType [E103]:"); - } + throw std::runtime_error("unknown value for enum MDEntryType [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, MDEntryType::Value m) { - return os << MDEntryType::c_str(m); - } + template + friend std::basic_ostream& operator << ( + std::basic_ostream& os, MDEntryType::Value m) + { + return os << MDEntryType::c_str(m); + } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDEntryTypeBook.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDEntryTypeBook.h index e0b36e97e..b6982ee43 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDEntryTypeBook.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDEntryTypeBook.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,65 +86,60 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class MDEntryTypeBook { - public: - enum Value { - Bid = (char)48, - Offer = (char)49, - ImpliedBid = (char)69, - ImpliedOffer = (char)70, - BookReset = (char)74, - NULL_VALUE = (char)0 - }; +class MDEntryTypeBook +{ +public: + enum Value + { + Bid = static_cast(48), + Offer = static_cast(49), + ImpliedBid = static_cast(69), + ImpliedOffer = static_cast(70), + BookReset = static_cast(74), + NULL_VALUE = static_cast(0) + }; - static MDEntryTypeBook::Value get(const char value) { - switch (value) { - case 48: - return Bid; - case 49: - return Offer; - case 69: - return ImpliedBid; - case 70: - return ImpliedOffer; - case 74: - return BookReset; - case 0: - return NULL_VALUE; - } + static MDEntryTypeBook::Value get(const char value) + { + switch (value) + { + case static_cast(48): return Bid; + case static_cast(49): return Offer; + case static_cast(69): return ImpliedBid; + case static_cast(70): return ImpliedOffer; + case static_cast(74): return BookReset; + case static_cast(0): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum MDEntryTypeBook [E103]"); - } + throw std::runtime_error("unknown value for enum MDEntryTypeBook [E103]"); + } - static const char *c_str(const MDEntryTypeBook::Value value) { - switch (value) { - case Bid: - return "Bid"; - case Offer: - return "Offer"; - case ImpliedBid: - return "ImpliedBid"; - case ImpliedOffer: - return "ImpliedOffer"; - case BookReset: - return "BookReset"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const MDEntryTypeBook::Value value) + { + switch (value) + { + case Bid: return "Bid"; + case Offer: return "Offer"; + case ImpliedBid: return "ImpliedBid"; + case ImpliedOffer: return "ImpliedOffer"; + case BookReset: return "BookReset"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum MDEntryTypeBook [E103]:"); - } + throw std::runtime_error("unknown value for enum MDEntryTypeBook [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, MDEntryTypeBook::Value m) { - return os << MDEntryTypeBook::c_str(m); - } + template + friend std::basic_ostream& operator << ( + std::basic_ostream& os, MDEntryTypeBook::Value m) + { + return os << MDEntryTypeBook::c_str(m); + } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDEntryTypeDailyStatistics.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDEntryTypeDailyStatistics.h index a0a74d8fd..e621c1b57 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDEntryTypeDailyStatistics.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDEntryTypeDailyStatistics.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,62 +86,57 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class MDEntryTypeDailyStatistics { - public: - enum Value { - SettlementPrice = (char)54, - ClearedVolume = (char)66, - OpenInterest = (char)67, - FixingPrice = (char)87, - NULL_VALUE = (char)0 - }; +class MDEntryTypeDailyStatistics +{ +public: + enum Value + { + SettlementPrice = static_cast(54), + ClearedVolume = static_cast(66), + OpenInterest = static_cast(67), + FixingPrice = static_cast(87), + NULL_VALUE = static_cast(0) + }; - static MDEntryTypeDailyStatistics::Value get(const char value) { - switch (value) { - case 54: - return SettlementPrice; - case 66: - return ClearedVolume; - case 67: - return OpenInterest; - case 87: - return FixingPrice; - case 0: - return NULL_VALUE; - } + static MDEntryTypeDailyStatistics::Value get(const char value) + { + switch (value) + { + case static_cast(54): return SettlementPrice; + case static_cast(66): return ClearedVolume; + case static_cast(67): return OpenInterest; + case static_cast(87): return FixingPrice; + case static_cast(0): return NULL_VALUE; + } - throw std::runtime_error( - "unknown value for enum MDEntryTypeDailyStatistics [E103]"); - } + throw std::runtime_error("unknown value for enum MDEntryTypeDailyStatistics [E103]"); + } - static const char *c_str(const MDEntryTypeDailyStatistics::Value value) { - switch (value) { - case SettlementPrice: - return "SettlementPrice"; - case ClearedVolume: - return "ClearedVolume"; - case OpenInterest: - return "OpenInterest"; - case FixingPrice: - return "FixingPrice"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const MDEntryTypeDailyStatistics::Value value) + { + switch (value) + { + case SettlementPrice: return "SettlementPrice"; + case ClearedVolume: return "ClearedVolume"; + case OpenInterest: return "OpenInterest"; + case FixingPrice: return "FixingPrice"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum MDEntryTypeDailyStatistics [E103]:"); - } + throw std::runtime_error("unknown value for enum MDEntryTypeDailyStatistics [E103]:"); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &os, - MDEntryTypeDailyStatistics::Value m) { - return os << MDEntryTypeDailyStatistics::c_str(m); - } + template + friend std::basic_ostream& operator << ( + std::basic_ostream& os, MDEntryTypeDailyStatistics::Value m) + { + return os << MDEntryTypeDailyStatistics::c_str(m); + } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDEntryTypeStatistics.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDEntryTypeStatistics.h index acdd8fbee..93d7ff037 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDEntryTypeStatistics.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDEntryTypeStatistics.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,66 +86,60 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class MDEntryTypeStatistics { - public: - enum Value { - OpenPrice = (char)52, - HighTrade = (char)55, - LowTrade = (char)56, - HighestBid = (char)78, - LowestOffer = (char)79, - NULL_VALUE = (char)0 - }; +class MDEntryTypeStatistics +{ +public: + enum Value + { + OpenPrice = static_cast(52), + HighTrade = static_cast(55), + LowTrade = static_cast(56), + HighestBid = static_cast(78), + LowestOffer = static_cast(79), + NULL_VALUE = static_cast(0) + }; - static MDEntryTypeStatistics::Value get(const char value) { - switch (value) { - case 52: - return OpenPrice; - case 55: - return HighTrade; - case 56: - return LowTrade; - case 78: - return HighestBid; - case 79: - return LowestOffer; - case 0: - return NULL_VALUE; - } + static MDEntryTypeStatistics::Value get(const char value) + { + switch (value) + { + case static_cast(52): return OpenPrice; + case static_cast(55): return HighTrade; + case static_cast(56): return LowTrade; + case static_cast(78): return HighestBid; + case static_cast(79): return LowestOffer; + case static_cast(0): return NULL_VALUE; + } - throw std::runtime_error( - "unknown value for enum MDEntryTypeStatistics [E103]"); - } + throw std::runtime_error("unknown value for enum MDEntryTypeStatistics [E103]"); + } - static const char *c_str(const MDEntryTypeStatistics::Value value) { - switch (value) { - case OpenPrice: - return "OpenPrice"; - case HighTrade: - return "HighTrade"; - case LowTrade: - return "LowTrade"; - case HighestBid: - return "HighestBid"; - case LowestOffer: - return "LowestOffer"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const MDEntryTypeStatistics::Value value) + { + switch (value) + { + case OpenPrice: return "OpenPrice"; + case HighTrade: return "HighTrade"; + case LowTrade: return "LowTrade"; + case HighestBid: return "HighestBid"; + case LowestOffer: return "LowestOffer"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum MDEntryTypeStatistics [E103]:"); - } + throw std::runtime_error("unknown value for enum MDEntryTypeStatistics [E103]:"); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &os, MDEntryTypeStatistics::Value m) { - return os << MDEntryTypeStatistics::c_str(m); - } + template + friend std::basic_ostream& operator << ( + std::basic_ostream& os, MDEntryTypeStatistics::Value m) + { + return os << MDEntryTypeStatistics::c_str(m); + } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshBook32.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshBook32.h index cba7e8b8a..a7e0ad62b 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshBook32.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshBook32.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,1576 +86,1824 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDIncrementalRefreshBook32 { - 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 MDIncrementalRefreshBook32 +{ +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; } + 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(11); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(32); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDIncrementalRefreshBook32() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDIncrementalRefreshBook32( - 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; - MDIncrementalRefreshBook32(char *buffer, const std::uint64_t bufferLength) - : MDIncrementalRefreshBook32( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDIncrementalRefreshBook32() = default; - MDIncrementalRefreshBook32( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDIncrementalRefreshBook32( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDIncrementalRefreshBook32( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)11; - } + MDIncrementalRefreshBook32(char *buffer, const std::uint64_t bufferLength) : + MDIncrementalRefreshBook32(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)32; - } + MDIncrementalRefreshBook32( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDIncrementalRefreshBook32(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(11); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "X"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(32); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDIncrementalRefreshBook32 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDIncrementalRefreshBook32( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDIncrementalRefreshBook32 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "X"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDIncrementalRefreshBook32( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDIncrementalRefreshBook32 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDIncrementalRefreshBook32(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDIncrementalRefreshBook32 &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 = MDIncrementalRefreshBook32( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDIncrementalRefreshBook32 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDIncrementalRefreshBook32( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDIncrementalRefreshBook32 &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 = MDIncrementalRefreshBook32(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MDIncrementalRefreshBook32 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + 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(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - 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 + 0, 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MDIncrementalRefreshBook32 & - transactTime(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; - } + MDIncrementalRefreshBook32 &transactTime(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 *MatchEventIndicatorMetaAttribute( - 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 *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - class NoMDEntries { + class NoMDEntries + { 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(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; + } + + 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 NoMDEntries &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(static_cast(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 *MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT + { + return 270; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICENULL m_mDEntryPx; + +public: + SBE_NODISCARD PRICENULL &mDEntryPx() + { + m_mDEntryPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_mDEntryPx; + } + + SBE_NODISCARD static const char *MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT + { + return 271; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntrySizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntrySizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t mDEntrySize() 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); + } + + NoMDEntries &mDEntrySize(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 *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 12; + } + + 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 + 12, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &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 *RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT + { + return 83; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t rptSeqSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= rptSeqSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t rptSeqEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t rptSeq() 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); + } + + NoMDEntries &rptSeq(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 *NumberOfOrdersMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t numberOfOrdersId() SBE_NOEXCEPT + { + return 346; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t numberOfOrdersSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool numberOfOrdersInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= numberOfOrdersSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t numberOfOrdersEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::int32_t numberOfOrdersNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t numberOfOrdersMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t numberOfOrdersMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t numberOfOrdersEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t numberOfOrders() 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); + } + + NoMDEntries &numberOfOrders(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 *MDPriceLevelMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDPriceLevelId() SBE_NOEXCEPT + { + return 1023; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDPriceLevelSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDPriceLevelInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDPriceLevelSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDPriceLevelEncodingOffset() SBE_NOEXCEPT + { + return 24; + } + + static SBE_CONSTEXPR std::uint8_t mDPriceLevelNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t mDPriceLevelMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t mDPriceLevelMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t mDPriceLevelEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t mDPriceLevel() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint8_t)); + return (val); + } + + NoMDEntries &mDPriceLevel(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *MDUpdateActionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT + { + return 279; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDUpdateActionSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 25; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 25, sizeof(std::uint8_t)); + return MDUpdateAction::get((val)); + } + + NoMDEntries &mDUpdateAction(const MDUpdateAction::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 25, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT + { + return 269; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingOffset() SBE_NOEXCEPT + { + return 26; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDEntryTypeBook::Value mDEntryType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 26, sizeof(char)); + return MDEntryTypeBook::get((val)); + } + + NoMDEntries &mDEntryType(const MDEntryTypeBook::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 26, &val, sizeof(char)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDEntries writer) + { + builder << '{'; + builder << R"("MDEntryPx": )"; + builder << writer.mDEntryPx(); + + builder << ", "; + builder << R"("MDEntrySize": )"; + builder << +writer.mDEntrySize(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("RptSeq": )"; + builder << +writer.rptSeq(); + + builder << ", "; + builder << R"("NumberOfOrders": )"; + builder << +writer.numberOfOrders(); + + builder << ", "; + builder << R"("MDPriceLevel": )"; + builder << +writer.mDPriceLevel(); + + builder << ", "; + builder << R"("MDUpdateAction": )"; + builder << '"' << writer.mDUpdateAction() << '"'; + + builder << ", "; + builder << R"("MDEntryType": )"; + builder << '"' << writer.mDEntryType() << '"'; + + 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)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; - } +private: + NoMDEntries m_noMDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 32; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDEntriesId() SBE_NOEXCEPT + { + return 268; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDEntries &noMDEntries() + { + m_noMDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDEntries &noMDEntriesCount(const std::uint8_t count) + { + m_noMDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDEntriesSinceVersion() 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 NoMDEntries &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 * - MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT { - return 270; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDEntryPxSinceVersion(); + return m_actingVersion >= noMDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } + } + class NoOrderIDEntries + { private: - PRICENULL m_mDEntryPx; + 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 PRICENULL &mDEntryPx() { - m_mDEntryPx.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_mDEntryPx; - } - - SBE_NODISCARD static const char * - MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT { - return 271; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntrySizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntrySizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t mDEntrySize() 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); - } - - NoMDEntries &mDEntrySize(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 * - 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 12; - } - - 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 + 12, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoMDEntries &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 * - RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT { return 83; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - rptSeqSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= rptSeqSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - rptSeqEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t rptSeq() 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); - } - - NoMDEntries &rptSeq(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 *NumberOfOrdersMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t numberOfOrdersId() SBE_NOEXCEPT { - return 346; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - numberOfOrdersSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool numberOfOrdersInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= numberOfOrdersSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - numberOfOrdersEncodingOffset() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::int32_t numberOfOrdersNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t numberOfOrdersMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t numberOfOrdersMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - numberOfOrdersEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t numberOfOrders() 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); - } - - NoMDEntries &numberOfOrders(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 *MDPriceLevelMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDPriceLevelId() SBE_NOEXCEPT { - return 1023; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDPriceLevelSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDPriceLevelInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDPriceLevelSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDPriceLevelEncodingOffset() SBE_NOEXCEPT { - return 24; - } - - static SBE_CONSTEXPR std::uint8_t mDPriceLevelNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t mDPriceLevelMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t mDPriceLevelMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - mDPriceLevelEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t mDPriceLevel() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint8_t)); - return (val); - } - - NoMDEntries &mDPriceLevel(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *MDUpdateActionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT { - return 279; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDUpdateActionSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 25; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 25, sizeof(std::uint8_t)); - return MDUpdateAction::get((val)); - } - - NoMDEntries & - mDUpdateAction(const MDUpdateAction::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 25, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT { - return 269; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingOffset() SBE_NOEXCEPT { - return 26; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDEntryTypeBook::Value mDEntryType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 26, sizeof(char)); - return MDEntryTypeBook::get((val)); - } - - NoMDEntries & - mDEntryType(const MDEntryTypeBook::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 26, &val, sizeof(char)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDEntries writer) { - builder << '{'; - builder << R"("MDEntryPx": )"; - builder << writer.mDEntryPx(); - - builder << ", "; - builder << R"("MDEntrySize": )"; - builder << +writer.mDEntrySize(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("RptSeq": )"; - builder << +writer.rptSeq(); - - builder << ", "; - builder << R"("NumberOfOrders": )"; - builder << +writer.numberOfOrders(); - - builder << ", "; - builder << R"("MDPriceLevel": )"; - builder << +writer.mDPriceLevel(); - - builder << ", "; - builder << R"("MDUpdateAction": )"; - builder << '"' << writer.mDUpdateAction() << '"'; - - builder << ", "; - builder << R"("MDEntryType": )"; - builder << '"' << writer.mDEntryType() << '"'; - - builder << '}'; - - return builder; - } - }; - - private: - NoMDEntries m_noMDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDEntriesId() SBE_NOEXCEPT { - return 268; - } - - SBE_NODISCARD inline NoMDEntries &noMDEntries() { - m_noMDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - NoMDEntries &noMDEntriesCount(const std::uint8_t count) { - m_noMDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoOrderIDEntries { - 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) { - GroupSize8Byte 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 + 8; - } - - 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 wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize8Byte 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 + 8; + } + + 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; + GroupSize8Byte dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(24)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 24; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 8; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 24; + } + + 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 NoOrderIDEntries &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; + GroupSize8Byte dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(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 *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 0; + } + + 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoOrderIDEntries &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 *MDOrderPriorityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDOrderPriorityId() SBE_NOEXCEPT + { + return 37707; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDOrderPrioritySinceVersion() SBE_NOEXCEPT + { + return 7; + } + + SBE_NODISCARD bool mDOrderPriorityInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDOrderPrioritySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDOrderPriorityEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t mDOrderPriorityNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + static SBE_CONSTEXPR std::uint64_t mDOrderPriorityMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t mDOrderPriorityMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t mDOrderPriorityEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t mDOrderPriority() const SBE_NOEXCEPT + { + if (m_actingVersion < 7) + { + return UINT64_C(0xffffffffffffffff); + } + + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoOrderIDEntries &mDOrderPriority(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 *MDDisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDDisplayQtyId() SBE_NOEXCEPT + { + return 37706; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDDisplayQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDDisplayQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDDisplayQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDDisplayQtyEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + + static SBE_CONSTEXPR std::int32_t mDDisplayQtyNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDDisplayQtyMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDDisplayQtyMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t mDDisplayQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t mDDisplayQty() 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); + } + + NoOrderIDEntries &mDDisplayQty(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; + } + + SBE_NODISCARD static const char *ReferenceIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t referenceIDId() SBE_NOEXCEPT + { + return 9633; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t referenceIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool referenceIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= referenceIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t referenceIDEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint8_t referenceIDNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } + + static SBE_CONSTEXPR std::uint8_t referenceIDMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t referenceIDMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t referenceIDEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t referenceID() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint8_t)); + return (val); + } + + NoOrderIDEntries &referenceID(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderUpdateActionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderUpdateActionId() SBE_NOEXCEPT + { + return 37708; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 7; + } + + SBE_NODISCARD bool orderUpdateActionInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderUpdateActionSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 21; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD OrderUpdateAction::Value orderUpdateAction() const + { + if (m_actingVersion < 7) + { + return OrderUpdateAction::NULL_VALUE; + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); + return OrderUpdateAction::get((val)); + } + + NoOrderIDEntries &orderUpdateAction(const OrderUpdateAction::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 21, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoOrderIDEntries writer) + { + builder << '{'; + builder << R"("OrderID": )"; + builder << +writer.orderID(); + + builder << ", "; + builder << R"("MDOrderPriority": )"; + builder << +writer.mDOrderPriority(); + + builder << ", "; + builder << R"("MDDisplayQty": )"; + builder << +writer.mDDisplayQty(); + + builder << ", "; + builder << R"("ReferenceID": )"; + builder << +writer.referenceID(); + + builder << ", "; + builder << R"("OrderUpdateAction": )"; + builder << '"' << writer.orderUpdateAction() << '"'; + + 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; - GroupSize8Byte dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)24); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 24; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 8; - } + } + }; - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 8; - } +private: + NoOrderIDEntries m_noOrderIDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 24; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoOrderIDEntriesId() SBE_NOEXCEPT + { + return 37705; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoOrderIDEntries &noOrderIDEntries() + { + m_noOrderIDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderIDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoOrderIDEntries &noOrderIDEntriesCount(const std::uint8_t count) + { + m_noOrderIDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderIDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noOrderIDEntriesSinceVersion() SBE_NOEXCEPT + { + return 7; + } - 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 NoOrderIDEntries &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; - GroupSize8Byte 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 * - 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 { + SBE_NODISCARD bool noOrderIDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= noOrderIDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - 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 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 + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoOrderIDEntries &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 *MDOrderPriorityMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDOrderPriorityId() SBE_NOEXCEPT { - return 37707; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDOrderPrioritySinceVersion() SBE_NOEXCEPT { - return 7; - } - - SBE_NODISCARD bool mDOrderPriorityInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDOrderPrioritySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDOrderPriorityEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::uint64_t - mDOrderPriorityNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } - - static SBE_CONSTEXPR std::uint64_t - mDOrderPriorityMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - mDOrderPriorityMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - mDOrderPriorityEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t mDOrderPriority() const SBE_NOEXCEPT { - if (m_actingVersion < 7) { - return 0xffffffffffffffffL; - } - - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoOrderIDEntries & - mDOrderPriority(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 *MDDisplayQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDDisplayQtyId() SBE_NOEXCEPT { - return 37706; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDDisplayQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDDisplayQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDDisplayQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDDisplayQtyEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - static SBE_CONSTEXPR std::int32_t mDDisplayQtyNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDDisplayQtyMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDDisplayQtyMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - mDDisplayQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t mDDisplayQty() 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); - } - - NoOrderIDEntries &mDDisplayQty(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; - } - - SBE_NODISCARD static const char * - ReferenceIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t referenceIDId() SBE_NOEXCEPT { - return 9633; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - referenceIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool referenceIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= referenceIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - referenceIDEncodingOffset() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint8_t referenceIDNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } - - static SBE_CONSTEXPR std::uint8_t referenceIDMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t referenceIDMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - referenceIDEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t referenceID() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint8_t)); - return (val); - } - - NoOrderIDEntries &referenceID(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *OrderUpdateActionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderUpdateActionId() SBE_NOEXCEPT { - return 37708; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderUpdateActionSinceVersion() SBE_NOEXCEPT { - return 7; - } - - SBE_NODISCARD bool orderUpdateActionInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderUpdateActionSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 21; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD OrderUpdateAction::Value - orderUpdateAction() const SBE_NOEXCEPT { - if (m_actingVersion < 7) { - return OrderUpdateAction::NULL_VALUE; - } - - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); - return OrderUpdateAction::get((val)); - } - - NoOrderIDEntries & - orderUpdateAction(const OrderUpdateAction::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 21, &val, sizeof(std::uint8_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoOrderIDEntries writer) { - builder << '{'; - builder << R"("OrderID": )"; - builder << +writer.orderID(); - - builder << ", "; - builder << R"("MDOrderPriority": )"; - builder << +writer.mDOrderPriority(); - - builder << ", "; - builder << R"("MDDisplayQty": )"; - builder << +writer.mDDisplayQty(); - - builder << ", "; - builder << R"("ReferenceID": )"; - builder << +writer.referenceID(); - - builder << ", "; - builder << R"("OrderUpdateAction": )"; - builder << '"' << writer.orderUpdateAction() << '"'; - - builder << '}'; - - return builder; - } - }; - - private: - NoOrderIDEntries m_noOrderIDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoOrderIDEntriesId() SBE_NOEXCEPT { - return 37705; - } - - SBE_NODISCARD inline NoOrderIDEntries &noOrderIDEntries() { - m_noOrderIDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderIDEntries; - } - - NoOrderIDEntries &noOrderIDEntriesCount(const std::uint8_t count) { - m_noOrderIDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderIDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noOrderIDEntriesSinceVersion() SBE_NOEXCEPT { - return 7; - } - - SBE_NODISCARD bool noOrderIDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noOrderIDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDIncrementalRefreshBook32 _writer) { - MDIncrementalRefreshBook32 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDIncrementalRefreshBook32", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDEntries": [)"; - writer.noMDEntries().forEach([&](NoMDEntries &noMDEntries) { - if (atLeastOne) { - builder << ", "; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDIncrementalRefreshBook32 _writer) +{ + MDIncrementalRefreshBook32 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDIncrementalRefreshBook32", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDEntries": [)"; + writer.noMDEntries().forEach([&](NoMDEntries& noMDEntries) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDEntries; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoOrderIDEntries": [)"; - writer.noOrderIDEntries().forEach( - [&](NoOrderIDEntries &noOrderIDEntries) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noOrderIDEntries; - }); - builder << ']'; - } + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoOrderIDEntries": [)"; + writer.noOrderIDEntries().forEach([&](NoOrderIDEntries& noOrderIDEntries) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noOrderIDEntries; + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noMDEntries().forEach([](NoMDEntries e) + { + e.skip(); + }); + noOrderIDEntries().forEach([](NoOrderIDEntries e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noMDEntriesLength = 0, + std::size_t noOrderIDEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoMDEntries::sbeHeaderSize(); + if (noMDEntriesLength > 254LL) + { + throw std::runtime_error("noMDEntriesLength outside of allowed range [E110]"); + } + length += noMDEntriesLength *NoMDEntries::sbeBlockLength(); + + length += NoOrderIDEntries::sbeHeaderSize(); + if (noOrderIDEntriesLength > 254LL) + { + throw std::runtime_error("noOrderIDEntriesLength outside of allowed range [E110]"); + } + length += noOrderIDEntriesLength *NoOrderIDEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshBook46.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshBook46.h index 95ca84361..52dd4a9e8 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshBook46.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshBook46.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,1576 +86,1824 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDIncrementalRefreshBook46 { - 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 MDIncrementalRefreshBook46 +{ +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; } + 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(11); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(46); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDIncrementalRefreshBook46() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDIncrementalRefreshBook46( - 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; - MDIncrementalRefreshBook46(char *buffer, const std::uint64_t bufferLength) - : MDIncrementalRefreshBook46( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDIncrementalRefreshBook46() = default; - MDIncrementalRefreshBook46( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDIncrementalRefreshBook46( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDIncrementalRefreshBook46( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)11; - } + MDIncrementalRefreshBook46(char *buffer, const std::uint64_t bufferLength) : + MDIncrementalRefreshBook46(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)46; - } + MDIncrementalRefreshBook46( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDIncrementalRefreshBook46(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(11); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "X"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(46); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDIncrementalRefreshBook46 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDIncrementalRefreshBook46( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDIncrementalRefreshBook46 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "X"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDIncrementalRefreshBook46( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDIncrementalRefreshBook46 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDIncrementalRefreshBook46(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDIncrementalRefreshBook46 &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 = MDIncrementalRefreshBook46( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDIncrementalRefreshBook46 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDIncrementalRefreshBook46( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDIncrementalRefreshBook46 &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 = MDIncrementalRefreshBook46(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MDIncrementalRefreshBook46 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + 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(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - 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 + 0, 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MDIncrementalRefreshBook46 & - transactTime(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; - } + MDIncrementalRefreshBook46 &transactTime(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 *MatchEventIndicatorMetaAttribute( - 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 *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - class NoMDEntries { + class NoMDEntries + { 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(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; + } + + 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 NoMDEntries &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(static_cast(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 *MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT + { + return 270; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryPxSinceVersion() SBE_NOEXCEPT + { + return 9; + } + + SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICENULL9 m_mDEntryPx; + +public: + SBE_NODISCARD PRICENULL9 &mDEntryPx() + { + m_mDEntryPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_mDEntryPx; + } + + SBE_NODISCARD static const char *MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT + { + return 271; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntrySizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntrySizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t mDEntrySize() 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); + } + + NoMDEntries &mDEntrySize(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 *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 12; + } + + 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 + 12, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &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 *RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT + { + return 83; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t rptSeqSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= rptSeqSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t rptSeqEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t rptSeq() 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); + } + + NoMDEntries &rptSeq(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 *NumberOfOrdersMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t numberOfOrdersId() SBE_NOEXCEPT + { + return 346; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t numberOfOrdersSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool numberOfOrdersInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= numberOfOrdersSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t numberOfOrdersEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::int32_t numberOfOrdersNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t numberOfOrdersMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t numberOfOrdersMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t numberOfOrdersEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t numberOfOrders() 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); + } + + NoMDEntries &numberOfOrders(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 *MDPriceLevelMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDPriceLevelId() SBE_NOEXCEPT + { + return 1023; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDPriceLevelSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDPriceLevelInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDPriceLevelSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDPriceLevelEncodingOffset() SBE_NOEXCEPT + { + return 24; + } + + static SBE_CONSTEXPR std::uint8_t mDPriceLevelNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } + + static SBE_CONSTEXPR std::uint8_t mDPriceLevelMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t mDPriceLevelMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t mDPriceLevelEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t mDPriceLevel() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint8_t)); + return (val); + } + + NoMDEntries &mDPriceLevel(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *MDUpdateActionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT + { + return 279; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDUpdateActionSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 25; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 25, sizeof(std::uint8_t)); + return MDUpdateAction::get((val)); + } + + NoMDEntries &mDUpdateAction(const MDUpdateAction::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 25, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT + { + return 269; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingOffset() SBE_NOEXCEPT + { + return 26; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDEntryTypeBook::Value mDEntryType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 26, sizeof(char)); + return MDEntryTypeBook::get((val)); + } + + NoMDEntries &mDEntryType(const MDEntryTypeBook::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 26, &val, sizeof(char)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDEntries writer) + { + builder << '{'; + builder << R"("MDEntryPx": )"; + builder << writer.mDEntryPx(); + + builder << ", "; + builder << R"("MDEntrySize": )"; + builder << +writer.mDEntrySize(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("RptSeq": )"; + builder << +writer.rptSeq(); + + builder << ", "; + builder << R"("NumberOfOrders": )"; + builder << +writer.numberOfOrders(); + + builder << ", "; + builder << R"("MDPriceLevel": )"; + builder << +writer.mDPriceLevel(); + + builder << ", "; + builder << R"("MDUpdateAction": )"; + builder << '"' << writer.mDUpdateAction() << '"'; + + builder << ", "; + builder << R"("MDEntryType": )"; + builder << '"' << writer.mDEntryType() << '"'; + + 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)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; - } +private: + NoMDEntries m_noMDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 32; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDEntriesId() SBE_NOEXCEPT + { + return 268; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDEntries &noMDEntries() + { + m_noMDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDEntries &noMDEntriesCount(const std::uint8_t count) + { + m_noMDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDEntriesSinceVersion() 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 NoMDEntries &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 * - MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT { - return 270; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryPxSinceVersion() SBE_NOEXCEPT { - return 9; - } - - SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDEntryPxSinceVersion(); + return m_actingVersion >= noMDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } + } + class NoOrderIDEntries + { private: - PRICENULL9 m_mDEntryPx; + 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 &mDEntryPx() { - m_mDEntryPx.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_mDEntryPx; - } - - SBE_NODISCARD static const char * - MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT { - return 271; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntrySizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntrySizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t mDEntrySize() 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); - } - - NoMDEntries &mDEntrySize(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 * - 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 12; - } - - 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 + 12, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoMDEntries &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 * - RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT { return 83; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - rptSeqSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= rptSeqSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - rptSeqEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t rptSeq() 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); - } - - NoMDEntries &rptSeq(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 *NumberOfOrdersMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t numberOfOrdersId() SBE_NOEXCEPT { - return 346; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - numberOfOrdersSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool numberOfOrdersInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= numberOfOrdersSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - numberOfOrdersEncodingOffset() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::int32_t numberOfOrdersNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t numberOfOrdersMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t numberOfOrdersMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - numberOfOrdersEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t numberOfOrders() 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); - } - - NoMDEntries &numberOfOrders(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 *MDPriceLevelMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDPriceLevelId() SBE_NOEXCEPT { - return 1023; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDPriceLevelSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDPriceLevelInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDPriceLevelSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDPriceLevelEncodingOffset() SBE_NOEXCEPT { - return 24; - } - - static SBE_CONSTEXPR std::uint8_t mDPriceLevelNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } - - static SBE_CONSTEXPR std::uint8_t mDPriceLevelMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t mDPriceLevelMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - mDPriceLevelEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t mDPriceLevel() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint8_t)); - return (val); - } - - NoMDEntries &mDPriceLevel(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *MDUpdateActionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT { - return 279; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDUpdateActionSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 25; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 25, sizeof(std::uint8_t)); - return MDUpdateAction::get((val)); - } - - NoMDEntries & - mDUpdateAction(const MDUpdateAction::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 25, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT { - return 269; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingOffset() SBE_NOEXCEPT { - return 26; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDEntryTypeBook::Value mDEntryType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 26, sizeof(char)); - return MDEntryTypeBook::get((val)); - } - - NoMDEntries & - mDEntryType(const MDEntryTypeBook::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 26, &val, sizeof(char)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDEntries writer) { - builder << '{'; - builder << R"("MDEntryPx": )"; - builder << writer.mDEntryPx(); - - builder << ", "; - builder << R"("MDEntrySize": )"; - builder << +writer.mDEntrySize(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("RptSeq": )"; - builder << +writer.rptSeq(); - - builder << ", "; - builder << R"("NumberOfOrders": )"; - builder << +writer.numberOfOrders(); - - builder << ", "; - builder << R"("MDPriceLevel": )"; - builder << +writer.mDPriceLevel(); - - builder << ", "; - builder << R"("MDUpdateAction": )"; - builder << '"' << writer.mDUpdateAction() << '"'; - - builder << ", "; - builder << R"("MDEntryType": )"; - builder << '"' << writer.mDEntryType() << '"'; - - builder << '}'; - - return builder; - } - }; - - private: - NoMDEntries m_noMDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDEntriesId() SBE_NOEXCEPT { - return 268; - } - - SBE_NODISCARD inline NoMDEntries &noMDEntries() { - m_noMDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - NoMDEntries &noMDEntriesCount(const std::uint8_t count) { - m_noMDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoOrderIDEntries { - 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) { - GroupSize8Byte 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 + 8; - } - - 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 wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize8Byte 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 + 8; + } + + 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; + GroupSize8Byte dimensions(buffer, *pos, bufferLength, actingVersion); + dimensions.blockLength(static_cast(24)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 24; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 8; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 24; + } + + 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 NoOrderIDEntries &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; + GroupSize8Byte dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(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 *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 0; + } + + 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoOrderIDEntries &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 *MDOrderPriorityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDOrderPriorityId() SBE_NOEXCEPT + { + return 37707; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDOrderPrioritySinceVersion() SBE_NOEXCEPT + { + return 7; + } + + SBE_NODISCARD bool mDOrderPriorityInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDOrderPrioritySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDOrderPriorityEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t mDOrderPriorityNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + static SBE_CONSTEXPR std::uint64_t mDOrderPriorityMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t mDOrderPriorityMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t mDOrderPriorityEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t mDOrderPriority() const SBE_NOEXCEPT + { + if (m_actingVersion < 7) + { + return UINT64_C(0xffffffffffffffff); + } + + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoOrderIDEntries &mDOrderPriority(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 *MDDisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDDisplayQtyId() SBE_NOEXCEPT + { + return 37706; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDDisplayQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDDisplayQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDDisplayQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDDisplayQtyEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + + static SBE_CONSTEXPR std::int32_t mDDisplayQtyNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDDisplayQtyMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDDisplayQtyMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t mDDisplayQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t mDDisplayQty() 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); + } + + NoOrderIDEntries &mDDisplayQty(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; + } + + SBE_NODISCARD static const char *ReferenceIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t referenceIDId() SBE_NOEXCEPT + { + return 9633; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t referenceIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool referenceIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= referenceIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t referenceIDEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint8_t referenceIDNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } + + static SBE_CONSTEXPR std::uint8_t referenceIDMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint8_t referenceIDMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } + + static SBE_CONSTEXPR std::size_t referenceIDEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::uint8_t referenceID() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint8_t)); + return (val); + } + + NoOrderIDEntries &referenceID(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *OrderUpdateActionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t orderUpdateActionId() SBE_NOEXCEPT + { + return 37708; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 7; + } + + SBE_NODISCARD bool orderUpdateActionInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= orderUpdateActionSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 21; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t orderUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD OrderUpdateAction::Value orderUpdateAction() const + { + if (m_actingVersion < 7) + { + return OrderUpdateAction::NULL_VALUE; + } + + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); + return OrderUpdateAction::get((val)); + } + + NoOrderIDEntries &orderUpdateAction(const OrderUpdateAction::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 21, &val, sizeof(std::uint8_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoOrderIDEntries writer) + { + builder << '{'; + builder << R"("OrderID": )"; + builder << +writer.orderID(); + + builder << ", "; + builder << R"("MDOrderPriority": )"; + builder << +writer.mDOrderPriority(); + + builder << ", "; + builder << R"("MDDisplayQty": )"; + builder << +writer.mDDisplayQty(); + + builder << ", "; + builder << R"("ReferenceID": )"; + builder << +writer.referenceID(); + + builder << ", "; + builder << R"("OrderUpdateAction": )"; + builder << '"' << writer.orderUpdateAction() << '"'; + + 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; - GroupSize8Byte dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)24); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 24; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 8; - } + } + }; - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 8; - } +private: + NoOrderIDEntries m_noOrderIDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 24; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoOrderIDEntriesId() SBE_NOEXCEPT + { + return 37705; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoOrderIDEntries &noOrderIDEntries() + { + m_noOrderIDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderIDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoOrderIDEntries &noOrderIDEntriesCount(const std::uint8_t count) + { + m_noOrderIDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderIDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noOrderIDEntriesSinceVersion() 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 NoOrderIDEntries &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; - GroupSize8Byte 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 * - 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 { + SBE_NODISCARD bool noOrderIDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= noOrderIDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - 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 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 + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoOrderIDEntries &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 *MDOrderPriorityMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDOrderPriorityId() SBE_NOEXCEPT { - return 37707; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDOrderPrioritySinceVersion() SBE_NOEXCEPT { - return 7; - } - - SBE_NODISCARD bool mDOrderPriorityInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDOrderPrioritySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDOrderPriorityEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::uint64_t - mDOrderPriorityNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } - - static SBE_CONSTEXPR std::uint64_t - mDOrderPriorityMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - mDOrderPriorityMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - mDOrderPriorityEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t mDOrderPriority() const SBE_NOEXCEPT { - if (m_actingVersion < 7) { - return 0xffffffffffffffffL; - } - - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoOrderIDEntries & - mDOrderPriority(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 *MDDisplayQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDDisplayQtyId() SBE_NOEXCEPT { - return 37706; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDDisplayQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDDisplayQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDDisplayQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDDisplayQtyEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - static SBE_CONSTEXPR std::int32_t mDDisplayQtyNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDDisplayQtyMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDDisplayQtyMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - mDDisplayQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t mDDisplayQty() 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); - } - - NoOrderIDEntries &mDDisplayQty(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; - } - - SBE_NODISCARD static const char * - ReferenceIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t referenceIDId() SBE_NOEXCEPT { - return 9633; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - referenceIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool referenceIDInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= referenceIDSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - referenceIDEncodingOffset() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint8_t referenceIDNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } - - static SBE_CONSTEXPR std::uint8_t referenceIDMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } - - static SBE_CONSTEXPR std::uint8_t referenceIDMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } - - static SBE_CONSTEXPR std::size_t - referenceIDEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::uint8_t referenceID() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 20, sizeof(std::uint8_t)); - return (val); - } - - NoOrderIDEntries &referenceID(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 20, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *OrderUpdateActionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t orderUpdateActionId() SBE_NOEXCEPT { - return 37708; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderUpdateActionSinceVersion() SBE_NOEXCEPT { - return 7; - } - - SBE_NODISCARD bool orderUpdateActionInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= orderUpdateActionSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 21; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD OrderUpdateAction::Value - orderUpdateAction() const SBE_NOEXCEPT { - if (m_actingVersion < 7) { - return OrderUpdateAction::NULL_VALUE; - } - - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 21, sizeof(std::uint8_t)); - return OrderUpdateAction::get((val)); - } - - NoOrderIDEntries & - orderUpdateAction(const OrderUpdateAction::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 21, &val, sizeof(std::uint8_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoOrderIDEntries writer) { - builder << '{'; - builder << R"("OrderID": )"; - builder << +writer.orderID(); - - builder << ", "; - builder << R"("MDOrderPriority": )"; - builder << +writer.mDOrderPriority(); - - builder << ", "; - builder << R"("MDDisplayQty": )"; - builder << +writer.mDDisplayQty(); - - builder << ", "; - builder << R"("ReferenceID": )"; - builder << +writer.referenceID(); - - builder << ", "; - builder << R"("OrderUpdateAction": )"; - builder << '"' << writer.orderUpdateAction() << '"'; - - builder << '}'; - - return builder; - } - }; - - private: - NoOrderIDEntries m_noOrderIDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoOrderIDEntriesId() SBE_NOEXCEPT { - return 37705; - } - - SBE_NODISCARD inline NoOrderIDEntries &noOrderIDEntries() { - m_noOrderIDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderIDEntries; - } - - NoOrderIDEntries &noOrderIDEntriesCount(const std::uint8_t count) { - m_noOrderIDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderIDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noOrderIDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noOrderIDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noOrderIDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDIncrementalRefreshBook46 _writer) { - MDIncrementalRefreshBook46 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDIncrementalRefreshBook46", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDEntries": [)"; - writer.noMDEntries().forEach([&](NoMDEntries &noMDEntries) { - if (atLeastOne) { - builder << ", "; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDIncrementalRefreshBook46 _writer) +{ + MDIncrementalRefreshBook46 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDIncrementalRefreshBook46", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDEntries": [)"; + writer.noMDEntries().forEach([&](NoMDEntries& noMDEntries) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDEntries; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoOrderIDEntries": [)"; - writer.noOrderIDEntries().forEach( - [&](NoOrderIDEntries &noOrderIDEntries) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noOrderIDEntries; - }); - builder << ']'; - } + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoOrderIDEntries": [)"; + writer.noOrderIDEntries().forEach([&](NoOrderIDEntries& noOrderIDEntries) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noOrderIDEntries; + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noMDEntries().forEach([](NoMDEntries e) + { + e.skip(); + }); + noOrderIDEntries().forEach([](NoOrderIDEntries e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noMDEntriesLength = 0, + std::size_t noOrderIDEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoMDEntries::sbeHeaderSize(); + if (noMDEntriesLength > 254LL) + { + throw std::runtime_error("noMDEntriesLength outside of allowed range [E110]"); + } + length += noMDEntriesLength *NoMDEntries::sbeBlockLength(); + + length += NoOrderIDEntries::sbeHeaderSize(); + if (noOrderIDEntriesLength > 254LL) + { + throw std::runtime_error("noOrderIDEntriesLength outside of allowed range [E110]"); + } + length += noOrderIDEntriesLength *NoOrderIDEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshDailyStatistics33.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshDailyStatistics33.h index a3e90ad14..e0a4d9c3e 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshDailyStatistics33.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshDailyStatistics33.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,1023 +86,1179 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDIncrementalRefreshDailyStatistics33 { - 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 MDIncrementalRefreshDailyStatistics33 +{ +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; } + 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(11); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(33); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDIncrementalRefreshDailyStatistics33() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDIncrementalRefreshDailyStatistics33( - 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; - MDIncrementalRefreshDailyStatistics33( - char *buffer, const std::uint64_t bufferLength) - : MDIncrementalRefreshDailyStatistics33( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDIncrementalRefreshDailyStatistics33() = default; - MDIncrementalRefreshDailyStatistics33( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDIncrementalRefreshDailyStatistics33( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDIncrementalRefreshDailyStatistics33( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)11; - } + MDIncrementalRefreshDailyStatistics33(char *buffer, const std::uint64_t bufferLength) : + MDIncrementalRefreshDailyStatistics33(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)33; - } + MDIncrementalRefreshDailyStatistics33( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDIncrementalRefreshDailyStatistics33(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(11); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "X"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(33); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDIncrementalRefreshDailyStatistics33 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDIncrementalRefreshDailyStatistics33( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDIncrementalRefreshDailyStatistics33 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "X"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDIncrementalRefreshDailyStatistics33( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDIncrementalRefreshDailyStatistics33 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDIncrementalRefreshDailyStatistics33(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDIncrementalRefreshDailyStatistics33 &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 = MDIncrementalRefreshDailyStatistics33( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDIncrementalRefreshDailyStatistics33 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDIncrementalRefreshDailyStatistics33( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDIncrementalRefreshDailyStatistics33 &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 = MDIncrementalRefreshDailyStatistics33(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MDIncrementalRefreshDailyStatistics33 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + 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(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - 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 + 0, 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MDIncrementalRefreshDailyStatistics33 & - transactTime(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; - } + MDIncrementalRefreshDailyStatistics33 &transactTime(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 *MatchEventIndicatorMetaAttribute( - 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 *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - class NoMDEntries { + class NoMDEntries + { 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(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; + } + + 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 NoMDEntries &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(static_cast(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 *MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT + { + return 270; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICENULL m_mDEntryPx; + +public: + SBE_NODISCARD PRICENULL &mDEntryPx() + { + m_mDEntryPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_mDEntryPx; + } + + SBE_NODISCARD static const char *MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT + { + return 271; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntrySizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntrySizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t mDEntrySize() 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); + } + + NoMDEntries &mDEntrySize(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 *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 12; + } + + 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 + 12, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &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 *RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT + { + return 83; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t rptSeqSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= rptSeqSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t rptSeqEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t rptSeq() 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); + } + + NoMDEntries &rptSeq(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 *TradingReferenceDateMetaAttribute(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 tradingReferenceDateId() SBE_NOEXCEPT + { + return 5796; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingReferenceDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= tradingReferenceDateSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t tradingReferenceDate() 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); + } + + NoMDEntries &tradingReferenceDate(const std::uint16_t 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; + } + + SBE_NODISCARD static const char *SettlPriceTypeMetaAttribute(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 settlPriceTypeId() SBE_NOEXCEPT + { + return 731; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t settlPriceTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= settlPriceTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingOffset() SBE_NOEXCEPT + { + return 22; + } + + private: + SettlPriceType m_settlPriceType; + + public: + SBE_NODISCARD SettlPriceType &settlPriceType() + { + m_settlPriceType.wrap(m_buffer, m_offset + 22, m_actingVersion, m_bufferLength); + return m_settlPriceType; + } + + static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD static const char *MDUpdateActionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT + { + return 279; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDUpdateActionSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 23; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 23, sizeof(std::uint8_t)); + return MDUpdateAction::get((val)); + } + + NoMDEntries &mDUpdateAction(const MDUpdateAction::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 23, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT + { + return 269; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingOffset() SBE_NOEXCEPT + { + return 24; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDEntryTypeDailyStatistics::Value mDEntryType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(char)); + return MDEntryTypeDailyStatistics::get((val)); + } + + NoMDEntries &mDEntryType(const MDEntryTypeDailyStatistics::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(char)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDEntries writer) + { + builder << '{'; + builder << R"("MDEntryPx": )"; + builder << writer.mDEntryPx(); + + builder << ", "; + builder << R"("MDEntrySize": )"; + builder << +writer.mDEntrySize(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("RptSeq": )"; + builder << +writer.rptSeq(); + + builder << ", "; + builder << R"("TradingReferenceDate": )"; + builder << +writer.tradingReferenceDate(); + + builder << ", "; + builder << R"("SettlPriceType": )"; + builder << writer.settlPriceType(); + + builder << ", "; + builder << R"("MDUpdateAction": )"; + builder << '"' << writer.mDUpdateAction() << '"'; + + builder << ", "; + builder << R"("MDEntryType": )"; + builder << '"' << writer.mDEntryType() << '"'; + + 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)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; - } +private: + NoMDEntries m_noMDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 32; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDEntriesId() SBE_NOEXCEPT + { + return 268; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDEntries &noMDEntries() + { + m_noMDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDEntries &noMDEntriesCount(const std::uint8_t count) + { + m_noMDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDEntriesSinceVersion() 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 NoMDEntries &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 * - MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT { - return 270; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDEntryPxSinceVersion(); + return m_actingVersion >= noMDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - private: - PRICENULL m_mDEntryPx; - - public: - SBE_NODISCARD PRICENULL &mDEntryPx() { - m_mDEntryPx.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_mDEntryPx; - } - - SBE_NODISCARD static const char * - MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT { - return 271; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntrySizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntrySizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t mDEntrySize() 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); - } - - NoMDEntries &mDEntrySize(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 * - 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 12; - } - - 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 + 12, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoMDEntries &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 * - RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT { return 83; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - rptSeqSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= rptSeqSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - rptSeqEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t rptSeq() 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); - } - - NoMDEntries &rptSeq(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 *TradingReferenceDateMetaAttribute( - 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 tradingReferenceDateId() SBE_NOEXCEPT { - return 5796; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingReferenceDateSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= tradingReferenceDateSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingOffset() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t tradingReferenceDate() 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); - } - - NoMDEntries & - tradingReferenceDate(const std::uint16_t 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; - } - - SBE_NODISCARD static const char *SettlPriceTypeMetaAttribute( - 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 settlPriceTypeId() SBE_NOEXCEPT { - return 731; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - settlPriceTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= settlPriceTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingOffset() SBE_NOEXCEPT { - return 22; - } - - private: - SettlPriceType m_settlPriceType; - - public: - SBE_NODISCARD SettlPriceType &settlPriceType() { - m_settlPriceType.wrap( - m_buffer, m_offset + 22, m_actingVersion, m_bufferLength); - return m_settlPriceType; - } - - static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD static const char *MDUpdateActionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT { - return 279; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDUpdateActionSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 23; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 23, sizeof(std::uint8_t)); - return MDUpdateAction::get((val)); - } - - NoMDEntries & - mDUpdateAction(const MDUpdateAction::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 23, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT { - return 269; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingOffset() SBE_NOEXCEPT { - return 24; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDEntryTypeDailyStatistics::Value - mDEntryType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 24, sizeof(char)); - return MDEntryTypeDailyStatistics::get((val)); - } - - NoMDEntries & - mDEntryType(const MDEntryTypeDailyStatistics::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(char)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDEntries writer) { - builder << '{'; - builder << R"("MDEntryPx": )"; - builder << writer.mDEntryPx(); - - builder << ", "; - builder << R"("MDEntrySize": )"; - builder << +writer.mDEntrySize(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("RptSeq": )"; - builder << +writer.rptSeq(); - - builder << ", "; - builder << R"("TradingReferenceDate": )"; - builder << +writer.tradingReferenceDate(); - - builder << ", "; - builder << R"("SettlPriceType": )"; - builder << writer.settlPriceType(); - - builder << ", "; - builder << R"("MDUpdateAction": )"; - builder << '"' << writer.mDUpdateAction() << '"'; - - builder << ", "; - builder << R"("MDEntryType": )"; - builder << '"' << writer.mDEntryType() << '"'; - - builder << '}'; - - return builder; - } - }; - - private: - NoMDEntries m_noMDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDEntriesId() SBE_NOEXCEPT { - return 268; - } - - SBE_NODISCARD inline NoMDEntries &noMDEntries() { - m_noMDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - NoMDEntries &noMDEntriesCount(const std::uint8_t count) { - m_noMDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDIncrementalRefreshDailyStatistics33 _writer) { - MDIncrementalRefreshDailyStatistics33 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDIncrementalRefreshDailyStatistics33", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDEntries": [)"; - writer.noMDEntries().forEach([&](NoMDEntries &noMDEntries) { - if (atLeastOne) { - builder << ", "; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDIncrementalRefreshDailyStatistics33 _writer) +{ + MDIncrementalRefreshDailyStatistics33 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDIncrementalRefreshDailyStatistics33", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDEntries": [)"; + writer.noMDEntries().forEach([&](NoMDEntries& noMDEntries) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDEntries; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noMDEntries().forEach([](NoMDEntries e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t noMDEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoMDEntries::sbeHeaderSize(); + if (noMDEntriesLength > 254LL) + { + throw std::runtime_error("noMDEntriesLength outside of allowed range [E110]"); + } + length += noMDEntriesLength *NoMDEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshDailyStatistics49.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshDailyStatistics49.h index c575542aa..0098573eb 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshDailyStatistics49.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshDailyStatistics49.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,1023 +86,1179 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDIncrementalRefreshDailyStatistics49 { - 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 MDIncrementalRefreshDailyStatistics49 +{ +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; } + 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(11); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(49); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDIncrementalRefreshDailyStatistics49() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDIncrementalRefreshDailyStatistics49( - 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; - MDIncrementalRefreshDailyStatistics49( - char *buffer, const std::uint64_t bufferLength) - : MDIncrementalRefreshDailyStatistics49( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDIncrementalRefreshDailyStatistics49() = default; - MDIncrementalRefreshDailyStatistics49( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDIncrementalRefreshDailyStatistics49( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDIncrementalRefreshDailyStatistics49( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)11; - } + MDIncrementalRefreshDailyStatistics49(char *buffer, const std::uint64_t bufferLength) : + MDIncrementalRefreshDailyStatistics49(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)49; - } + MDIncrementalRefreshDailyStatistics49( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDIncrementalRefreshDailyStatistics49(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(11); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "X"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(49); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDIncrementalRefreshDailyStatistics49 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDIncrementalRefreshDailyStatistics49( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDIncrementalRefreshDailyStatistics49 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "X"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDIncrementalRefreshDailyStatistics49( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDIncrementalRefreshDailyStatistics49 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDIncrementalRefreshDailyStatistics49(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDIncrementalRefreshDailyStatistics49 &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 = MDIncrementalRefreshDailyStatistics49( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDIncrementalRefreshDailyStatistics49 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDIncrementalRefreshDailyStatistics49( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDIncrementalRefreshDailyStatistics49 &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 = MDIncrementalRefreshDailyStatistics49(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MDIncrementalRefreshDailyStatistics49 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + 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(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - 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 + 0, 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MDIncrementalRefreshDailyStatistics49 & - transactTime(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; - } + MDIncrementalRefreshDailyStatistics49 &transactTime(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 *MatchEventIndicatorMetaAttribute( - 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 *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - class NoMDEntries { + class NoMDEntries + { 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(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; + } + + 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 NoMDEntries &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(static_cast(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 *MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT + { + return 270; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryPxSinceVersion() SBE_NOEXCEPT + { + return 9; + } + + SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICENULL9 m_mDEntryPx; + +public: + SBE_NODISCARD PRICENULL9 &mDEntryPx() + { + m_mDEntryPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_mDEntryPx; + } + + SBE_NODISCARD static const char *MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT + { + return 271; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntrySizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntrySizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t mDEntrySize() 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); + } + + NoMDEntries &mDEntrySize(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 *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 12; + } + + 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 + 12, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &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 *RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT + { + return 83; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t rptSeqSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= rptSeqSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t rptSeqEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t rptSeq() 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); + } + + NoMDEntries &rptSeq(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 *TradingReferenceDateMetaAttribute(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 tradingReferenceDateId() SBE_NOEXCEPT + { + return 5796; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingReferenceDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= tradingReferenceDateSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t tradingReferenceDate() 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); + } + + NoMDEntries &tradingReferenceDate(const std::uint16_t 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; + } + + SBE_NODISCARD static const char *SettlPriceTypeMetaAttribute(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 settlPriceTypeId() SBE_NOEXCEPT + { + return 731; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t settlPriceTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= settlPriceTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingOffset() SBE_NOEXCEPT + { + return 22; + } + + private: + SettlPriceType m_settlPriceType; + + public: + SBE_NODISCARD SettlPriceType &settlPriceType() + { + m_settlPriceType.wrap(m_buffer, m_offset + 22, m_actingVersion, m_bufferLength); + return m_settlPriceType; + } + + static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD static const char *MDUpdateActionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT + { + return 279; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDUpdateActionSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 23; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 23, sizeof(std::uint8_t)); + return MDUpdateAction::get((val)); + } + + NoMDEntries &mDUpdateAction(const MDUpdateAction::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 23, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT + { + return 269; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingOffset() SBE_NOEXCEPT + { + return 24; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDEntryTypeDailyStatistics::Value mDEntryType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(char)); + return MDEntryTypeDailyStatistics::get((val)); + } + + NoMDEntries &mDEntryType(const MDEntryTypeDailyStatistics::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(char)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDEntries writer) + { + builder << '{'; + builder << R"("MDEntryPx": )"; + builder << writer.mDEntryPx(); + + builder << ", "; + builder << R"("MDEntrySize": )"; + builder << +writer.mDEntrySize(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("RptSeq": )"; + builder << +writer.rptSeq(); + + builder << ", "; + builder << R"("TradingReferenceDate": )"; + builder << +writer.tradingReferenceDate(); + + builder << ", "; + builder << R"("SettlPriceType": )"; + builder << writer.settlPriceType(); + + builder << ", "; + builder << R"("MDUpdateAction": )"; + builder << '"' << writer.mDUpdateAction() << '"'; + + builder << ", "; + builder << R"("MDEntryType": )"; + builder << '"' << writer.mDEntryType() << '"'; + + 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)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; - } +private: + NoMDEntries m_noMDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 32; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDEntriesId() SBE_NOEXCEPT + { + return 268; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDEntries &noMDEntries() + { + m_noMDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDEntries &noMDEntriesCount(const std::uint8_t count) + { + m_noMDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDEntriesSinceVersion() 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 NoMDEntries &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 * - MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT { - return 270; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryPxSinceVersion() SBE_NOEXCEPT { - return 9; - } - - SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDEntryPxSinceVersion(); + return m_actingVersion >= noMDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - private: - PRICENULL9 m_mDEntryPx; - - public: - SBE_NODISCARD PRICENULL9 &mDEntryPx() { - m_mDEntryPx.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_mDEntryPx; - } - - SBE_NODISCARD static const char * - MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT { - return 271; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntrySizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntrySizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t mDEntrySize() 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); - } - - NoMDEntries &mDEntrySize(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 * - 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 12; - } - - 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 + 12, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoMDEntries &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 * - RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT { return 83; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - rptSeqSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= rptSeqSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - rptSeqEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t rptSeq() 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); - } - - NoMDEntries &rptSeq(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 *TradingReferenceDateMetaAttribute( - 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 tradingReferenceDateId() SBE_NOEXCEPT { - return 5796; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingReferenceDateSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= tradingReferenceDateSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingOffset() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t tradingReferenceDate() 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); - } - - NoMDEntries & - tradingReferenceDate(const std::uint16_t 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; - } - - SBE_NODISCARD static const char *SettlPriceTypeMetaAttribute( - 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 settlPriceTypeId() SBE_NOEXCEPT { - return 731; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - settlPriceTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= settlPriceTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingOffset() SBE_NOEXCEPT { - return 22; - } - - private: - SettlPriceType m_settlPriceType; - - public: - SBE_NODISCARD SettlPriceType &settlPriceType() { - m_settlPriceType.wrap( - m_buffer, m_offset + 22, m_actingVersion, m_bufferLength); - return m_settlPriceType; - } - - static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD static const char *MDUpdateActionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT { - return 279; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDUpdateActionSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 23; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 23, sizeof(std::uint8_t)); - return MDUpdateAction::get((val)); - } - - NoMDEntries & - mDUpdateAction(const MDUpdateAction::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 23, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT { - return 269; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingOffset() SBE_NOEXCEPT { - return 24; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDEntryTypeDailyStatistics::Value - mDEntryType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 24, sizeof(char)); - return MDEntryTypeDailyStatistics::get((val)); - } - - NoMDEntries & - mDEntryType(const MDEntryTypeDailyStatistics::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(char)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDEntries writer) { - builder << '{'; - builder << R"("MDEntryPx": )"; - builder << writer.mDEntryPx(); - - builder << ", "; - builder << R"("MDEntrySize": )"; - builder << +writer.mDEntrySize(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("RptSeq": )"; - builder << +writer.rptSeq(); - - builder << ", "; - builder << R"("TradingReferenceDate": )"; - builder << +writer.tradingReferenceDate(); - - builder << ", "; - builder << R"("SettlPriceType": )"; - builder << writer.settlPriceType(); - - builder << ", "; - builder << R"("MDUpdateAction": )"; - builder << '"' << writer.mDUpdateAction() << '"'; - - builder << ", "; - builder << R"("MDEntryType": )"; - builder << '"' << writer.mDEntryType() << '"'; - - builder << '}'; - - return builder; - } - }; - - private: - NoMDEntries m_noMDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDEntriesId() SBE_NOEXCEPT { - return 268; - } - - SBE_NODISCARD inline NoMDEntries &noMDEntries() { - m_noMDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - NoMDEntries &noMDEntriesCount(const std::uint8_t count) { - m_noMDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDIncrementalRefreshDailyStatistics49 _writer) { - MDIncrementalRefreshDailyStatistics49 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDIncrementalRefreshDailyStatistics49", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDEntries": [)"; - writer.noMDEntries().forEach([&](NoMDEntries &noMDEntries) { - if (atLeastOne) { - builder << ", "; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDIncrementalRefreshDailyStatistics49 _writer) +{ + MDIncrementalRefreshDailyStatistics49 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDIncrementalRefreshDailyStatistics49", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDEntries": [)"; + writer.noMDEntries().forEach([&](NoMDEntries& noMDEntries) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDEntries; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noMDEntries().forEach([](NoMDEntries e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t noMDEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoMDEntries::sbeHeaderSize(); + if (noMDEntriesLength > 254LL) + { + throw std::runtime_error("noMDEntriesLength outside of allowed range [E110]"); + } + length += noMDEntriesLength *NoMDEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshLimitsBanding34.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshLimitsBanding34.h index 4c8ef58af..2ba597cff 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshLimitsBanding34.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshLimitsBanding34.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,993 +86,1142 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDIncrementalRefreshLimitsBanding34 { - 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 MDIncrementalRefreshLimitsBanding34 +{ +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; } + 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(11); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(34); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDIncrementalRefreshLimitsBanding34() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDIncrementalRefreshLimitsBanding34( - 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; - MDIncrementalRefreshLimitsBanding34( - char *buffer, const std::uint64_t bufferLength) - : MDIncrementalRefreshLimitsBanding34( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDIncrementalRefreshLimitsBanding34() = default; - MDIncrementalRefreshLimitsBanding34( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDIncrementalRefreshLimitsBanding34( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDIncrementalRefreshLimitsBanding34( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)11; - } + MDIncrementalRefreshLimitsBanding34(char *buffer, const std::uint64_t bufferLength) : + MDIncrementalRefreshLimitsBanding34(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)34; - } + MDIncrementalRefreshLimitsBanding34( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDIncrementalRefreshLimitsBanding34(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(11); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "X"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(34); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDIncrementalRefreshLimitsBanding34 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDIncrementalRefreshLimitsBanding34( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDIncrementalRefreshLimitsBanding34 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "X"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDIncrementalRefreshLimitsBanding34( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDIncrementalRefreshLimitsBanding34 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDIncrementalRefreshLimitsBanding34(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDIncrementalRefreshLimitsBanding34 &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 = MDIncrementalRefreshLimitsBanding34( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDIncrementalRefreshLimitsBanding34 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDIncrementalRefreshLimitsBanding34( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDIncrementalRefreshLimitsBanding34 &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 = MDIncrementalRefreshLimitsBanding34(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MDIncrementalRefreshLimitsBanding34 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + 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(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - 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 + 0, 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MDIncrementalRefreshLimitsBanding34 & - transactTime(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; - } + MDIncrementalRefreshLimitsBanding34 &transactTime(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 *MatchEventIndicatorMetaAttribute( - 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 *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - class NoMDEntries { + class NoMDEntries + { 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(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; + } + + 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 NoMDEntries &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(static_cast(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 *HighLimitPriceMetaAttribute(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 highLimitPriceId() SBE_NOEXCEPT + { + return 1149; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t highLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= highLimitPriceSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t highLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICENULL m_highLimitPrice; + +public: + SBE_NODISCARD PRICENULL &highLimitPrice() + { + m_highLimitPrice.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_highLimitPrice; + } + + SBE_NODISCARD static const char *LowLimitPriceMetaAttribute(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 lowLimitPriceId() SBE_NOEXCEPT + { + return 1148; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lowLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= lowLimitPriceSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lowLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + +private: + PRICENULL m_lowLimitPrice; + +public: + SBE_NODISCARD PRICENULL &lowLimitPrice() + { + m_lowLimitPrice.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_lowLimitPrice; + } + + SBE_NODISCARD static const char *MaxPriceVariationMetaAttribute(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 maxPriceVariationId() SBE_NOEXCEPT + { + return 1143; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maxPriceVariationSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool maxPriceVariationInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= maxPriceVariationSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maxPriceVariationEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + +private: + PRICENULL m_maxPriceVariation; + +public: + SBE_NODISCARD PRICENULL &maxPriceVariation() + { + m_maxPriceVariation.wrap(m_buffer, m_offset + 16, m_actingVersion, m_bufferLength); + return m_maxPriceVariation; + } + + 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 24; + } + + 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 + 24, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT + { + return 83; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t rptSeqSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= rptSeqSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t rptSeqEncodingOffset() SBE_NOEXCEPT + { + return 28; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t rptSeq() 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); + } + + NoMDEntries &rptSeq(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 *MDUpdateActionMetaAttribute(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 mDUpdateActionId() SBE_NOEXCEPT + { + return 279; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDUpdateActionSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 32; + } + + static SBE_CONSTEXPR std::int8_t mDUpdateActionNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t mDUpdateActionMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t mDUpdateActionMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::int8_t mDUpdateAction() SBE_NOEXCEPT + { + return static_cast(0); + } + + SBE_NODISCARD static const char *MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT + { + return 269; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingOffset() SBE_NOEXCEPT + { + return 32; + } + + static SBE_CONSTEXPR char mDEntryTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char mDEntryTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char mDEntryTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t mDEntryTypeLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *mDEntryType() const + { + static const std::uint8_t mDEntryTypeValues[] = { 103 }; + + return (const char *)mDEntryTypeValues; + } + + SBE_NODISCARD char mDEntryType(const std::uint64_t index) const + { + static const std::uint8_t mDEntryTypeValues[] = { 103 }; + + return (char)mDEntryTypeValues[index]; + } + + std::uint64_t getMDEntryType(char *dst, const std::uint64_t length) const + { + static std::uint8_t mDEntryTypeValues[] = { 103 }; + std::uint64_t bytesToCopy = length < sizeof(mDEntryTypeValues) ? length : sizeof(mDEntryTypeValues); + + std::memcpy(dst, mDEntryTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getMDEntryTypeAsString() const + { + static const std::uint8_t MDEntryTypeValues[] = { 103 }; + + return std::string((const char *)MDEntryTypeValues, 1); + } + + std::string getMDEntryTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getMDEntryTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDEntries writer) + { + builder << '{'; + builder << R"("HighLimitPrice": )"; + builder << writer.highLimitPrice(); + + builder << ", "; + builder << R"("LowLimitPrice": )"; + builder << writer.lowLimitPrice(); + + builder << ", "; + builder << R"("MaxPriceVariation": )"; + builder << writer.maxPriceVariation(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("RptSeq": )"; + builder << +writer.rptSeq(); + + 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)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; - } +private: + NoMDEntries m_noMDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 32; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDEntriesId() SBE_NOEXCEPT + { + return 268; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDEntries &noMDEntries() + { + m_noMDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDEntries &noMDEntriesCount(const std::uint8_t count) + { + m_noMDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDEntriesSinceVersion() 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 NoMDEntries &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 *HighLimitPriceMetaAttribute( - 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 highLimitPriceId() SBE_NOEXCEPT { - return 1149; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - highLimitPriceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= highLimitPriceSinceVersion(); + return m_actingVersion >= noMDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - highLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - private: - PRICENULL m_highLimitPrice; - - public: - SBE_NODISCARD PRICENULL &highLimitPrice() { - m_highLimitPrice.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_highLimitPrice; - } - - SBE_NODISCARD static const char *LowLimitPriceMetaAttribute( - 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 lowLimitPriceId() SBE_NOEXCEPT { - return 1148; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lowLimitPriceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= lowLimitPriceSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lowLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - private: - PRICENULL m_lowLimitPrice; - - public: - SBE_NODISCARD PRICENULL &lowLimitPrice() { - m_lowLimitPrice.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_lowLimitPrice; - } - - SBE_NODISCARD static const char *MaxPriceVariationMetaAttribute( - 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 maxPriceVariationId() SBE_NOEXCEPT { - return 1143; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - maxPriceVariationSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool maxPriceVariationInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= maxPriceVariationSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maxPriceVariationEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - private: - PRICENULL m_maxPriceVariation; - - public: - SBE_NODISCARD PRICENULL &maxPriceVariation() { - m_maxPriceVariation.wrap( - m_buffer, m_offset + 16, m_actingVersion, m_bufferLength); - return m_maxPriceVariation; - } - - 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 24; - } - - 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 + 24, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoMDEntries &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char * - RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT { return 83; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - rptSeqSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= rptSeqSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - rptSeqEncodingOffset() SBE_NOEXCEPT { - return 28; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t rptSeq() 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); - } - - NoMDEntries &rptSeq(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 *MDUpdateActionMetaAttribute( - 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 mDUpdateActionId() SBE_NOEXCEPT { - return 279; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDUpdateActionSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 32; - } - - static SBE_CONSTEXPR std::int8_t mDUpdateActionNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t mDUpdateActionMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t mDUpdateActionMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingLength() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::int8_t - mDUpdateAction() SBE_NOEXCEPT { - return (std::int8_t)0; - } - - SBE_NODISCARD static const char * - MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT { - return 269; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingOffset() SBE_NOEXCEPT { - return 32; - } - - static SBE_CONSTEXPR char mDEntryTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char mDEntryTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char mDEntryTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t mDEntryTypeLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *mDEntryType() const { - static const std::uint8_t mDEntryTypeValues[] = {103}; - - return (const char *)mDEntryTypeValues; - } - - SBE_NODISCARD char mDEntryType(const std::uint64_t index) const { - static const std::uint8_t mDEntryTypeValues[] = {103}; - - return (char)mDEntryTypeValues[index]; - } - - std::uint64_t - getMDEntryType(char *dst, const std::uint64_t length) const { - static std::uint8_t mDEntryTypeValues[] = {103}; - std::uint64_t bytesToCopy = length < sizeof(mDEntryTypeValues) - ? length - : sizeof(mDEntryTypeValues); - - std::memcpy(dst, mDEntryTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getMDEntryTypeAsString() const { - static const std::uint8_t MDEntryTypeValues[] = {103}; - - return std::string((const char *)MDEntryTypeValues, 1); - } - - std::string getMDEntryTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getMDEntryTypeAsString(); - - 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(); - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDEntries writer) { - builder << '{'; - builder << R"("HighLimitPrice": )"; - builder << writer.highLimitPrice(); - - builder << ", "; - builder << R"("LowLimitPrice": )"; - builder << writer.lowLimitPrice(); - - builder << ", "; - builder << R"("MaxPriceVariation": )"; - builder << writer.maxPriceVariation(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("RptSeq": )"; - builder << +writer.rptSeq(); - - builder << '}'; - - return builder; - } - }; - - private: - NoMDEntries m_noMDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDEntriesId() SBE_NOEXCEPT { - return 268; - } - - SBE_NODISCARD inline NoMDEntries &noMDEntries() { - m_noMDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - NoMDEntries &noMDEntriesCount(const std::uint8_t count) { - m_noMDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDIncrementalRefreshLimitsBanding34 _writer) { - MDIncrementalRefreshLimitsBanding34 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDIncrementalRefreshLimitsBanding34", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDEntries": [)"; - writer.noMDEntries().forEach([&](NoMDEntries &noMDEntries) { - if (atLeastOne) { - builder << ", "; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDIncrementalRefreshLimitsBanding34 _writer) +{ + MDIncrementalRefreshLimitsBanding34 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDIncrementalRefreshLimitsBanding34", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDEntries": [)"; + writer.noMDEntries().forEach([&](NoMDEntries& noMDEntries) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDEntries; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noMDEntries().forEach([](NoMDEntries e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t noMDEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoMDEntries::sbeHeaderSize(); + if (noMDEntriesLength > 254LL) + { + throw std::runtime_error("noMDEntriesLength outside of allowed range [E110]"); + } + length += noMDEntriesLength *NoMDEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshLimitsBanding50.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshLimitsBanding50.h index a0ac0992b..c2f2058cd 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshLimitsBanding50.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshLimitsBanding50.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,993 +86,1142 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDIncrementalRefreshLimitsBanding50 { - 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 MDIncrementalRefreshLimitsBanding50 +{ +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; } + 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(11); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(50); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDIncrementalRefreshLimitsBanding50() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDIncrementalRefreshLimitsBanding50( - 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; - MDIncrementalRefreshLimitsBanding50( - char *buffer, const std::uint64_t bufferLength) - : MDIncrementalRefreshLimitsBanding50( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDIncrementalRefreshLimitsBanding50() = default; - MDIncrementalRefreshLimitsBanding50( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDIncrementalRefreshLimitsBanding50( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDIncrementalRefreshLimitsBanding50( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)11; - } + MDIncrementalRefreshLimitsBanding50(char *buffer, const std::uint64_t bufferLength) : + MDIncrementalRefreshLimitsBanding50(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)50; - } + MDIncrementalRefreshLimitsBanding50( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDIncrementalRefreshLimitsBanding50(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(11); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "X"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(50); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDIncrementalRefreshLimitsBanding50 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDIncrementalRefreshLimitsBanding50( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDIncrementalRefreshLimitsBanding50 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "X"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDIncrementalRefreshLimitsBanding50( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDIncrementalRefreshLimitsBanding50 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDIncrementalRefreshLimitsBanding50(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDIncrementalRefreshLimitsBanding50 &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 = MDIncrementalRefreshLimitsBanding50( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDIncrementalRefreshLimitsBanding50 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDIncrementalRefreshLimitsBanding50( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDIncrementalRefreshLimitsBanding50 &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 = MDIncrementalRefreshLimitsBanding50(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MDIncrementalRefreshLimitsBanding50 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + 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(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - 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 + 0, 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MDIncrementalRefreshLimitsBanding50 & - transactTime(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; - } + MDIncrementalRefreshLimitsBanding50 &transactTime(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 *MatchEventIndicatorMetaAttribute( - 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 *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - class NoMDEntries { + class NoMDEntries + { 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(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; + } + + 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 NoMDEntries &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(static_cast(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 *HighLimitPriceMetaAttribute(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 highLimitPriceId() SBE_NOEXCEPT + { + return 1149; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t highLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 9; + } + + SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= highLimitPriceSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t highLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICENULL9 m_highLimitPrice; + +public: + SBE_NODISCARD PRICENULL9 &highLimitPrice() + { + m_highLimitPrice.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_highLimitPrice; + } + + SBE_NODISCARD static const char *LowLimitPriceMetaAttribute(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 lowLimitPriceId() SBE_NOEXCEPT + { + return 1148; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lowLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 9; + } + + SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= lowLimitPriceSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lowLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + +private: + PRICENULL9 m_lowLimitPrice; + +public: + SBE_NODISCARD PRICENULL9 &lowLimitPrice() + { + m_lowLimitPrice.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_lowLimitPrice; + } + + SBE_NODISCARD static const char *MaxPriceVariationMetaAttribute(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 maxPriceVariationId() SBE_NOEXCEPT + { + return 1143; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maxPriceVariationSinceVersion() SBE_NOEXCEPT + { + return 9; + } + + SBE_NODISCARD bool maxPriceVariationInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= maxPriceVariationSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maxPriceVariationEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + +private: + PRICENULL9 m_maxPriceVariation; + +public: + SBE_NODISCARD PRICENULL9 &maxPriceVariation() + { + m_maxPriceVariation.wrap(m_buffer, m_offset + 16, m_actingVersion, m_bufferLength); + return m_maxPriceVariation; + } + + 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 24; + } + + 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 + 24, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT + { + return 83; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t rptSeqSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= rptSeqSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t rptSeqEncodingOffset() SBE_NOEXCEPT + { + return 28; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t rptSeq() 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); + } + + NoMDEntries &rptSeq(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 *MDUpdateActionMetaAttribute(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 mDUpdateActionId() SBE_NOEXCEPT + { + return 279; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDUpdateActionSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 32; + } + + static SBE_CONSTEXPR std::int8_t mDUpdateActionNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t mDUpdateActionMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t mDUpdateActionMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::int8_t mDUpdateAction() SBE_NOEXCEPT + { + return static_cast(0); + } + + SBE_NODISCARD static const char *MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT + { + return 269; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingOffset() SBE_NOEXCEPT + { + return 32; + } + + static SBE_CONSTEXPR char mDEntryTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char mDEntryTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char mDEntryTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t mDEntryTypeLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *mDEntryType() const + { + static const std::uint8_t mDEntryTypeValues[] = { 103 }; + + return (const char *)mDEntryTypeValues; + } + + SBE_NODISCARD char mDEntryType(const std::uint64_t index) const + { + static const std::uint8_t mDEntryTypeValues[] = { 103 }; + + return (char)mDEntryTypeValues[index]; + } + + std::uint64_t getMDEntryType(char *dst, const std::uint64_t length) const + { + static std::uint8_t mDEntryTypeValues[] = { 103 }; + std::uint64_t bytesToCopy = length < sizeof(mDEntryTypeValues) ? length : sizeof(mDEntryTypeValues); + + std::memcpy(dst, mDEntryTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getMDEntryTypeAsString() const + { + static const std::uint8_t MDEntryTypeValues[] = { 103 }; + + return std::string((const char *)MDEntryTypeValues, 1); + } + + std::string getMDEntryTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getMDEntryTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDEntries writer) + { + builder << '{'; + builder << R"("HighLimitPrice": )"; + builder << writer.highLimitPrice(); + + builder << ", "; + builder << R"("LowLimitPrice": )"; + builder << writer.lowLimitPrice(); + + builder << ", "; + builder << R"("MaxPriceVariation": )"; + builder << writer.maxPriceVariation(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("RptSeq": )"; + builder << +writer.rptSeq(); + + 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)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; - } +private: + NoMDEntries m_noMDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 32; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDEntriesId() SBE_NOEXCEPT + { + return 268; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDEntries &noMDEntries() + { + m_noMDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDEntries &noMDEntriesCount(const std::uint8_t count) + { + m_noMDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDEntriesSinceVersion() 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 NoMDEntries &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 *HighLimitPriceMetaAttribute( - 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 highLimitPriceId() SBE_NOEXCEPT { - return 1149; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - highLimitPriceSinceVersion() SBE_NOEXCEPT { - return 9; - } - - SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= highLimitPriceSinceVersion(); + return m_actingVersion >= noMDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - highLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - private: - PRICENULL9 m_highLimitPrice; - - public: - SBE_NODISCARD PRICENULL9 &highLimitPrice() { - m_highLimitPrice.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_highLimitPrice; - } - - SBE_NODISCARD static const char *LowLimitPriceMetaAttribute( - 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 lowLimitPriceId() SBE_NOEXCEPT { - return 1148; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lowLimitPriceSinceVersion() SBE_NOEXCEPT { - return 9; - } - - SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= lowLimitPriceSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lowLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - private: - PRICENULL9 m_lowLimitPrice; - - public: - SBE_NODISCARD PRICENULL9 &lowLimitPrice() { - m_lowLimitPrice.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_lowLimitPrice; - } - - SBE_NODISCARD static const char *MaxPriceVariationMetaAttribute( - 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 maxPriceVariationId() SBE_NOEXCEPT { - return 1143; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - maxPriceVariationSinceVersion() SBE_NOEXCEPT { - return 9; - } - - SBE_NODISCARD bool maxPriceVariationInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= maxPriceVariationSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maxPriceVariationEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - private: - PRICENULL9 m_maxPriceVariation; - - public: - SBE_NODISCARD PRICENULL9 &maxPriceVariation() { - m_maxPriceVariation.wrap( - m_buffer, m_offset + 16, m_actingVersion, m_bufferLength); - return m_maxPriceVariation; - } - - 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 24; - } - - 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 + 24, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoMDEntries &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char * - RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT { return 83; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - rptSeqSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= rptSeqSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - rptSeqEncodingOffset() SBE_NOEXCEPT { - return 28; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t rptSeq() 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); - } - - NoMDEntries &rptSeq(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 *MDUpdateActionMetaAttribute( - 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 mDUpdateActionId() SBE_NOEXCEPT { - return 279; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDUpdateActionSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 32; - } - - static SBE_CONSTEXPR std::int8_t mDUpdateActionNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t mDUpdateActionMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t mDUpdateActionMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingLength() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::int8_t - mDUpdateAction() SBE_NOEXCEPT { - return (std::int8_t)0; - } - - SBE_NODISCARD static const char * - MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT { - return 269; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingOffset() SBE_NOEXCEPT { - return 32; - } - - static SBE_CONSTEXPR char mDEntryTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char mDEntryTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char mDEntryTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t mDEntryTypeLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *mDEntryType() const { - static const std::uint8_t mDEntryTypeValues[] = {103}; - - return (const char *)mDEntryTypeValues; - } - - SBE_NODISCARD char mDEntryType(const std::uint64_t index) const { - static const std::uint8_t mDEntryTypeValues[] = {103}; - - return (char)mDEntryTypeValues[index]; - } - - std::uint64_t - getMDEntryType(char *dst, const std::uint64_t length) const { - static std::uint8_t mDEntryTypeValues[] = {103}; - std::uint64_t bytesToCopy = length < sizeof(mDEntryTypeValues) - ? length - : sizeof(mDEntryTypeValues); - - std::memcpy(dst, mDEntryTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getMDEntryTypeAsString() const { - static const std::uint8_t MDEntryTypeValues[] = {103}; - - return std::string((const char *)MDEntryTypeValues, 1); - } - - std::string getMDEntryTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getMDEntryTypeAsString(); - - 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(); - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDEntries writer) { - builder << '{'; - builder << R"("HighLimitPrice": )"; - builder << writer.highLimitPrice(); - - builder << ", "; - builder << R"("LowLimitPrice": )"; - builder << writer.lowLimitPrice(); - - builder << ", "; - builder << R"("MaxPriceVariation": )"; - builder << writer.maxPriceVariation(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("RptSeq": )"; - builder << +writer.rptSeq(); - - builder << '}'; - - return builder; - } - }; - - private: - NoMDEntries m_noMDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDEntriesId() SBE_NOEXCEPT { - return 268; - } - - SBE_NODISCARD inline NoMDEntries &noMDEntries() { - m_noMDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - NoMDEntries &noMDEntriesCount(const std::uint8_t count) { - m_noMDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDIncrementalRefreshLimitsBanding50 _writer) { - MDIncrementalRefreshLimitsBanding50 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDIncrementalRefreshLimitsBanding50", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDEntries": [)"; - writer.noMDEntries().forEach([&](NoMDEntries &noMDEntries) { - if (atLeastOne) { - builder << ", "; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDIncrementalRefreshLimitsBanding50 _writer) +{ + MDIncrementalRefreshLimitsBanding50 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDIncrementalRefreshLimitsBanding50", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDEntries": [)"; + writer.noMDEntries().forEach([&](NoMDEntries& noMDEntries) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDEntries; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noMDEntries().forEach([](NoMDEntries e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t noMDEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoMDEntries::sbeHeaderSize(); + if (noMDEntriesLength > 254LL) + { + throw std::runtime_error("noMDEntriesLength outside of allowed range [E110]"); + } + length += noMDEntriesLength *NoMDEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshOrderBook43.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshOrderBook43.h index 69236fdcd..5bf8a2702 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshOrderBook43.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshOrderBook43.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,973 +86,1133 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDIncrementalRefreshOrderBook43 { - 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 MDIncrementalRefreshOrderBook43 +{ +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; } + 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(11); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(43); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDIncrementalRefreshOrderBook43() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDIncrementalRefreshOrderBook43( - 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; - MDIncrementalRefreshOrderBook43( - char *buffer, const std::uint64_t bufferLength) - : MDIncrementalRefreshOrderBook43( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDIncrementalRefreshOrderBook43() = default; - MDIncrementalRefreshOrderBook43( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDIncrementalRefreshOrderBook43( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDIncrementalRefreshOrderBook43( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)11; - } + MDIncrementalRefreshOrderBook43(char *buffer, const std::uint64_t bufferLength) : + MDIncrementalRefreshOrderBook43(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)43; - } + MDIncrementalRefreshOrderBook43( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDIncrementalRefreshOrderBook43(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(11); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "X"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(43); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDIncrementalRefreshOrderBook43 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDIncrementalRefreshOrderBook43( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDIncrementalRefreshOrderBook43 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "X"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDIncrementalRefreshOrderBook43( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDIncrementalRefreshOrderBook43 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDIncrementalRefreshOrderBook43(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDIncrementalRefreshOrderBook43 &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 = MDIncrementalRefreshOrderBook43( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDIncrementalRefreshOrderBook43 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDIncrementalRefreshOrderBook43( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDIncrementalRefreshOrderBook43 &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 = MDIncrementalRefreshOrderBook43(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MDIncrementalRefreshOrderBook43 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + 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(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - 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 + 0, 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MDIncrementalRefreshOrderBook43 & - transactTime(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; - } + MDIncrementalRefreshOrderBook43 &transactTime(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 *MatchEventIndicatorMetaAttribute( - 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 *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - class NoMDEntries { + class NoMDEntries + { 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(40)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 40; + 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 40; + } + + 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 NoMDEntries &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(static_cast(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 *OrderIDMetaAttribute(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 orderIDId() SBE_NOEXCEPT + { + return 37; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t orderIDSinceVersion() SBE_NOEXCEPT + { + return 7; + } + + 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 0; + } + + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + 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 + { + if (m_actingVersion < 7) + { + return UINT64_C(0xffffffffffffffff); + } + + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoMDEntries &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 *MDOrderPriorityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDOrderPriorityId() SBE_NOEXCEPT + { + return 37707; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDOrderPrioritySinceVersion() SBE_NOEXCEPT + { + return 7; + } + + SBE_NODISCARD bool mDOrderPriorityInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDOrderPrioritySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDOrderPriorityEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t mDOrderPriorityNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + static SBE_CONSTEXPR std::uint64_t mDOrderPriorityMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t mDOrderPriorityMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t mDOrderPriorityEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t mDOrderPriority() const SBE_NOEXCEPT + { + if (m_actingVersion < 7) + { + return UINT64_C(0xffffffffffffffff); + } + + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoMDEntries &mDOrderPriority(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 *MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT + { + return 270; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryPxEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + +private: + PRICENULL m_mDEntryPx; + +public: + SBE_NODISCARD PRICENULL &mDEntryPx() + { + m_mDEntryPx.wrap(m_buffer, m_offset + 16, m_actingVersion, m_bufferLength); + return m_mDEntryPx; + } + + SBE_NODISCARD static const char *MDDisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDDisplayQtyId() SBE_NOEXCEPT + { + return 37706; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDDisplayQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDDisplayQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDDisplayQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDDisplayQtyEncodingOffset() SBE_NOEXCEPT + { + return 24; + } + + static SBE_CONSTEXPR std::int32_t mDDisplayQtyNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDDisplayQtyMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDDisplayQtyMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t mDDisplayQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t mDDisplayQty() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &mDDisplayQty(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::int32_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 28; + } + + 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 + 28, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *MDUpdateActionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT + { + return 279; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDUpdateActionSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 32; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::uint8_t)); + return MDUpdateAction::get((val)); + } + + NoMDEntries &mDUpdateAction(const MDUpdateAction::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 *MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT + { + return 269; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingOffset() SBE_NOEXCEPT + { + return 33; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDEntryTypeBook::Value mDEntryType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 33, sizeof(char)); + return MDEntryTypeBook::get((val)); + } + + NoMDEntries &mDEntryType(const MDEntryTypeBook::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 33, &val, sizeof(char)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDEntries writer) + { + builder << '{'; + builder << R"("OrderID": )"; + builder << +writer.orderID(); + + builder << ", "; + builder << R"("MDOrderPriority": )"; + builder << +writer.mDOrderPriority(); + + builder << ", "; + builder << R"("MDEntryPx": )"; + builder << writer.mDEntryPx(); + + builder << ", "; + builder << R"("MDDisplayQty": )"; + builder << +writer.mDDisplayQty(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("MDUpdateAction": )"; + builder << '"' << writer.mDUpdateAction() << '"'; + + builder << ", "; + builder << R"("MDEntryType": )"; + builder << '"' << writer.mDEntryType() << '"'; + + 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)40); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 40; - 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: + NoMDEntries m_noMDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 40; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDEntriesId() SBE_NOEXCEPT + { + return 268; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDEntries &noMDEntries() + { + m_noMDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDEntries &noMDEntriesCount(const std::uint8_t count) + { + m_noMDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDEntriesSinceVersion() 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 NoMDEntries &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 * - OrderIDMetaAttribute(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 orderIDId() SBE_NOEXCEPT { return 37; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - orderIDSinceVersion() SBE_NOEXCEPT { - return 7; - } - - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= noMDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } - - 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 { - if (m_actingVersion < 7) { - return 0xffffffffffffffffL; - } - - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoMDEntries &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 *MDOrderPriorityMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDOrderPriorityId() SBE_NOEXCEPT { - return 37707; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDOrderPrioritySinceVersion() SBE_NOEXCEPT { - return 7; - } - - SBE_NODISCARD bool mDOrderPriorityInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDOrderPrioritySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDOrderPriorityEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::uint64_t - mDOrderPriorityNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } - - static SBE_CONSTEXPR std::uint64_t - mDOrderPriorityMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - mDOrderPriorityMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - mDOrderPriorityEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t mDOrderPriority() const SBE_NOEXCEPT { - if (m_actingVersion < 7) { - return 0xffffffffffffffffL; - } - - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoMDEntries &mDOrderPriority(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 * - MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT { - return 270; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryPxSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryPxEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - private: - PRICENULL m_mDEntryPx; - - public: - SBE_NODISCARD PRICENULL &mDEntryPx() { - m_mDEntryPx.wrap( - m_buffer, m_offset + 16, m_actingVersion, m_bufferLength); - return m_mDEntryPx; - } - - SBE_NODISCARD static const char *MDDisplayQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDDisplayQtyId() SBE_NOEXCEPT { - return 37706; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDDisplayQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDDisplayQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDDisplayQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDDisplayQtyEncodingOffset() SBE_NOEXCEPT { - return 24; - } - - static SBE_CONSTEXPR std::int32_t mDDisplayQtyNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDDisplayQtyMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDDisplayQtyMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - mDDisplayQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t mDDisplayQty() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoMDEntries &mDDisplayQty(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::int32_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 28; - } - - 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 + 28, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoMDEntries &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char *MDUpdateActionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT { - return 279; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDUpdateActionSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 32; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::uint8_t)); - return MDUpdateAction::get((val)); - } - - NoMDEntries & - mDUpdateAction(const MDUpdateAction::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 * - MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT { - return 269; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingOffset() SBE_NOEXCEPT { - return 33; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDEntryTypeBook::Value mDEntryType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 33, sizeof(char)); - return MDEntryTypeBook::get((val)); - } - - NoMDEntries & - mDEntryType(const MDEntryTypeBook::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 33, &val, sizeof(char)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDEntries writer) { - builder << '{'; - builder << R"("OrderID": )"; - builder << +writer.orderID(); - - builder << ", "; - builder << R"("MDOrderPriority": )"; - builder << +writer.mDOrderPriority(); - - builder << ", "; - builder << R"("MDEntryPx": )"; - builder << writer.mDEntryPx(); - - builder << ", "; - builder << R"("MDDisplayQty": )"; - builder << +writer.mDDisplayQty(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("MDUpdateAction": )"; - builder << '"' << writer.mDUpdateAction() << '"'; - - builder << ", "; - builder << R"("MDEntryType": )"; - builder << '"' << writer.mDEntryType() << '"'; - - builder << '}'; - - return builder; - } - }; - - private: - NoMDEntries m_noMDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDEntriesId() SBE_NOEXCEPT { - return 268; - } - - SBE_NODISCARD inline NoMDEntries &noMDEntries() { - m_noMDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - NoMDEntries &noMDEntriesCount(const std::uint8_t count) { - m_noMDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDIncrementalRefreshOrderBook43 _writer) { - MDIncrementalRefreshOrderBook43 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDIncrementalRefreshOrderBook43", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDEntries": [)"; - writer.noMDEntries().forEach([&](NoMDEntries &noMDEntries) { - if (atLeastOne) { - builder << ", "; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDIncrementalRefreshOrderBook43 _writer) +{ + MDIncrementalRefreshOrderBook43 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDIncrementalRefreshOrderBook43", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDEntries": [)"; + writer.noMDEntries().forEach([&](NoMDEntries& noMDEntries) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDEntries; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noMDEntries().forEach([](NoMDEntries e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t noMDEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoMDEntries::sbeHeaderSize(); + if (noMDEntriesLength > 254LL) + { + throw std::runtime_error("noMDEntriesLength outside of allowed range [E110]"); + } + length += noMDEntriesLength *NoMDEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshOrderBook47.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshOrderBook47.h index a0df04a4d..cab5a8132 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshOrderBook47.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshOrderBook47.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,973 +86,1133 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDIncrementalRefreshOrderBook47 { - 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 MDIncrementalRefreshOrderBook47 +{ +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; } + 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(11); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(47); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDIncrementalRefreshOrderBook47() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDIncrementalRefreshOrderBook47( - 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; - MDIncrementalRefreshOrderBook47( - char *buffer, const std::uint64_t bufferLength) - : MDIncrementalRefreshOrderBook47( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDIncrementalRefreshOrderBook47() = default; - MDIncrementalRefreshOrderBook47( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDIncrementalRefreshOrderBook47( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDIncrementalRefreshOrderBook47( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)11; - } + MDIncrementalRefreshOrderBook47(char *buffer, const std::uint64_t bufferLength) : + MDIncrementalRefreshOrderBook47(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)47; - } + MDIncrementalRefreshOrderBook47( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDIncrementalRefreshOrderBook47(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(11); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "X"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(47); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDIncrementalRefreshOrderBook47 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDIncrementalRefreshOrderBook47( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDIncrementalRefreshOrderBook47 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "X"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDIncrementalRefreshOrderBook47( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDIncrementalRefreshOrderBook47 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDIncrementalRefreshOrderBook47(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDIncrementalRefreshOrderBook47 &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 = MDIncrementalRefreshOrderBook47( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDIncrementalRefreshOrderBook47 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDIncrementalRefreshOrderBook47( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDIncrementalRefreshOrderBook47 &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 = MDIncrementalRefreshOrderBook47(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MDIncrementalRefreshOrderBook47 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + 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(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - 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 + 0, 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MDIncrementalRefreshOrderBook47 & - transactTime(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; - } + MDIncrementalRefreshOrderBook47 &transactTime(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 *MatchEventIndicatorMetaAttribute( - 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 *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - class NoMDEntries { + class NoMDEntries + { 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(40)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 40; + 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 40; + } + + 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 NoMDEntries &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(static_cast(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 *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 7; + } + + 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 0; + } + + static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + 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 + { + if (m_actingVersion < 7) + { + return UINT64_C(0xffffffffffffffff); + } + + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoMDEntries &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 *MDOrderPriorityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDOrderPriorityId() SBE_NOEXCEPT + { + return 37707; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDOrderPrioritySinceVersion() SBE_NOEXCEPT + { + return 7; + } + + SBE_NODISCARD bool mDOrderPriorityInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDOrderPrioritySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDOrderPriorityEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t mDOrderPriorityNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + static SBE_CONSTEXPR std::uint64_t mDOrderPriorityMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t mDOrderPriorityMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t mDOrderPriorityEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t mDOrderPriority() const SBE_NOEXCEPT + { + if (m_actingVersion < 7) + { + return UINT64_C(0xffffffffffffffff); + } + + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoMDEntries &mDOrderPriority(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 *MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT + { + return 270; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryPxSinceVersion() SBE_NOEXCEPT + { + return 9; + } + + SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryPxEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + +private: + PRICENULL9 m_mDEntryPx; + +public: + SBE_NODISCARD PRICENULL9 &mDEntryPx() + { + m_mDEntryPx.wrap(m_buffer, m_offset + 16, m_actingVersion, m_bufferLength); + return m_mDEntryPx; + } + + SBE_NODISCARD static const char *MDDisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDDisplayQtyId() SBE_NOEXCEPT + { + return 37706; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDDisplayQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDDisplayQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDDisplayQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDDisplayQtyEncodingOffset() SBE_NOEXCEPT + { + return 24; + } + + static SBE_CONSTEXPR std::int32_t mDDisplayQtyNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDDisplayQtyMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDDisplayQtyMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t mDDisplayQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t mDDisplayQty() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &mDDisplayQty(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::int32_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 28; + } + + 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 + 28, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *MDUpdateActionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT + { + return 279; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDUpdateActionSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 32; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::uint8_t)); + return MDUpdateAction::get((val)); + } + + NoMDEntries &mDUpdateAction(const MDUpdateAction::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 *MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT + { + return 269; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingOffset() SBE_NOEXCEPT + { + return 33; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDEntryTypeBook::Value mDEntryType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 33, sizeof(char)); + return MDEntryTypeBook::get((val)); + } + + NoMDEntries &mDEntryType(const MDEntryTypeBook::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 33, &val, sizeof(char)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDEntries writer) + { + builder << '{'; + builder << R"("OrderID": )"; + builder << +writer.orderID(); + + builder << ", "; + builder << R"("MDOrderPriority": )"; + builder << +writer.mDOrderPriority(); + + builder << ", "; + builder << R"("MDEntryPx": )"; + builder << writer.mDEntryPx(); + + builder << ", "; + builder << R"("MDDisplayQty": )"; + builder << +writer.mDDisplayQty(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("MDUpdateAction": )"; + builder << '"' << writer.mDUpdateAction() << '"'; + + builder << ", "; + builder << R"("MDEntryType": )"; + builder << '"' << writer.mDEntryType() << '"'; + + 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)40); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 40; - 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: + NoMDEntries m_noMDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 40; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDEntriesId() SBE_NOEXCEPT + { + return 268; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDEntries &noMDEntries() + { + m_noMDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDEntries &noMDEntriesCount(const std::uint8_t count) + { + m_noMDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDEntriesSinceVersion() 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 NoMDEntries &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 * - 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 7; - } - - SBE_NODISCARD bool orderIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= noMDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } - - 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 { - if (m_actingVersion < 7) { - return 0xffffffffffffffffL; - } - - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoMDEntries &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 *MDOrderPriorityMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDOrderPriorityId() SBE_NOEXCEPT { - return 37707; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDOrderPrioritySinceVersion() SBE_NOEXCEPT { - return 7; - } - - SBE_NODISCARD bool mDOrderPriorityInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDOrderPrioritySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDOrderPriorityEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::uint64_t - mDOrderPriorityNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } - - static SBE_CONSTEXPR std::uint64_t - mDOrderPriorityMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - mDOrderPriorityMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - mDOrderPriorityEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t mDOrderPriority() const SBE_NOEXCEPT { - if (m_actingVersion < 7) { - return 0xffffffffffffffffL; - } - - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoMDEntries &mDOrderPriority(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 * - MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT { - return 270; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryPxSinceVersion() SBE_NOEXCEPT { - return 9; - } - - SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryPxSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryPxEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - private: - PRICENULL9 m_mDEntryPx; - - public: - SBE_NODISCARD PRICENULL9 &mDEntryPx() { - m_mDEntryPx.wrap( - m_buffer, m_offset + 16, m_actingVersion, m_bufferLength); - return m_mDEntryPx; - } - - SBE_NODISCARD static const char *MDDisplayQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDDisplayQtyId() SBE_NOEXCEPT { - return 37706; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDDisplayQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDDisplayQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDDisplayQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDDisplayQtyEncodingOffset() SBE_NOEXCEPT { - return 24; - } - - static SBE_CONSTEXPR std::int32_t mDDisplayQtyNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDDisplayQtyMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDDisplayQtyMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - mDDisplayQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t mDDisplayQty() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoMDEntries &mDDisplayQty(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::int32_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 28; - } - - 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 + 28, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoMDEntries &securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char *MDUpdateActionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT { - return 279; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDUpdateActionSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 32; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 32, sizeof(std::uint8_t)); - return MDUpdateAction::get((val)); - } - - NoMDEntries & - mDUpdateAction(const MDUpdateAction::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 * - MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT { - return 269; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingOffset() SBE_NOEXCEPT { - return 33; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDEntryTypeBook::Value mDEntryType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 33, sizeof(char)); - return MDEntryTypeBook::get((val)); - } - - NoMDEntries & - mDEntryType(const MDEntryTypeBook::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 33, &val, sizeof(char)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDEntries writer) { - builder << '{'; - builder << R"("OrderID": )"; - builder << +writer.orderID(); - - builder << ", "; - builder << R"("MDOrderPriority": )"; - builder << +writer.mDOrderPriority(); - - builder << ", "; - builder << R"("MDEntryPx": )"; - builder << writer.mDEntryPx(); - - builder << ", "; - builder << R"("MDDisplayQty": )"; - builder << +writer.mDDisplayQty(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("MDUpdateAction": )"; - builder << '"' << writer.mDUpdateAction() << '"'; - - builder << ", "; - builder << R"("MDEntryType": )"; - builder << '"' << writer.mDEntryType() << '"'; - - builder << '}'; - - return builder; - } - }; - - private: - NoMDEntries m_noMDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDEntriesId() SBE_NOEXCEPT { - return 268; - } - - SBE_NODISCARD inline NoMDEntries &noMDEntries() { - m_noMDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - NoMDEntries &noMDEntriesCount(const std::uint8_t count) { - m_noMDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDIncrementalRefreshOrderBook47 _writer) { - MDIncrementalRefreshOrderBook47 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDIncrementalRefreshOrderBook47", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDEntries": [)"; - writer.noMDEntries().forEach([&](NoMDEntries &noMDEntries) { - if (atLeastOne) { - builder << ", "; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDIncrementalRefreshOrderBook47 _writer) +{ + MDIncrementalRefreshOrderBook47 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDIncrementalRefreshOrderBook47", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDEntries": [)"; + writer.noMDEntries().forEach([&](NoMDEntries& noMDEntries) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDEntries; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noMDEntries().forEach([](NoMDEntries e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t noMDEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoMDEntries::sbeHeaderSize(); + if (noMDEntriesLength > 254LL) + { + throw std::runtime_error("noMDEntriesLength outside of allowed range [E110]"); + } + length += noMDEntriesLength *NoMDEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshSessionStatistics35.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshSessionStatistics35.h index 3f1342ab8..e5d7794b3 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshSessionStatistics35.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshSessionStatistics35.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,957 +86,1113 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDIncrementalRefreshSessionStatistics35 { - 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 MDIncrementalRefreshSessionStatistics35 +{ +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; } + 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(11); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(35); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDIncrementalRefreshSessionStatistics35() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDIncrementalRefreshSessionStatistics35( - 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; - MDIncrementalRefreshSessionStatistics35( - char *buffer, const std::uint64_t bufferLength) - : MDIncrementalRefreshSessionStatistics35( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDIncrementalRefreshSessionStatistics35() = default; - MDIncrementalRefreshSessionStatistics35( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDIncrementalRefreshSessionStatistics35( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDIncrementalRefreshSessionStatistics35( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)11; - } + MDIncrementalRefreshSessionStatistics35(char *buffer, const std::uint64_t bufferLength) : + MDIncrementalRefreshSessionStatistics35(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)35; - } + MDIncrementalRefreshSessionStatistics35( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDIncrementalRefreshSessionStatistics35(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(11); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "X"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(35); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDIncrementalRefreshSessionStatistics35 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDIncrementalRefreshSessionStatistics35( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDIncrementalRefreshSessionStatistics35 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "X"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDIncrementalRefreshSessionStatistics35( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDIncrementalRefreshSessionStatistics35 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDIncrementalRefreshSessionStatistics35(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDIncrementalRefreshSessionStatistics35 &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 = MDIncrementalRefreshSessionStatistics35( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDIncrementalRefreshSessionStatistics35 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDIncrementalRefreshSessionStatistics35( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDIncrementalRefreshSessionStatistics35 &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 = MDIncrementalRefreshSessionStatistics35(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MDIncrementalRefreshSessionStatistics35 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + 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(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - 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 + 0, 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MDIncrementalRefreshSessionStatistics35 & - transactTime(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; - } + MDIncrementalRefreshSessionStatistics35 &transactTime(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 *MatchEventIndicatorMetaAttribute( - 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 *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - class NoMDEntries { + class NoMDEntries + { 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(24)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 24; + 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 24; + } + + 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 NoMDEntries &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(static_cast(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 *MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT + { + return 270; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICE m_mDEntryPx; + +public: + SBE_NODISCARD PRICE &mDEntryPx() + { + m_mDEntryPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_mDEntryPx; + } + + 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 8; + } + + 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 + 8, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &securityID(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 *RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT + { + return 83; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t rptSeqSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= rptSeqSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t rptSeqEncodingOffset() SBE_NOEXCEPT + { + return 12; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t rptSeq() 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); + } + + NoMDEntries &rptSeq(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 *OpenCloseSettlFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t openCloseSettlFlagId() SBE_NOEXCEPT + { + return 286; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t openCloseSettlFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool openCloseSettlFlagInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= openCloseSettlFlagSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t openCloseSettlFlagEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t openCloseSettlFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD OpenCloseSettlFlag::Value openCloseSettlFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return OpenCloseSettlFlag::get((val)); + } + + NoMDEntries &openCloseSettlFlag(const OpenCloseSettlFlag::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 *MDUpdateActionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT + { + return 279; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDUpdateActionSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 17; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint8_t)); + return MDUpdateAction::get((val)); + } + + NoMDEntries &mDUpdateAction(const MDUpdateAction::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 *MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT + { + return 269; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingOffset() SBE_NOEXCEPT + { + return 18; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDEntryTypeStatistics::Value mDEntryType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 18, sizeof(char)); + return MDEntryTypeStatistics::get((val)); + } + + NoMDEntries &mDEntryType(const MDEntryTypeStatistics::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 18, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT + { + return 271; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntrySizeSinceVersion() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntrySizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingOffset() SBE_NOEXCEPT + { + return 19; + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t mDEntrySize() const SBE_NOEXCEPT + { + if (m_actingVersion < 8) + { + return INT32_C(2147483647); + } + + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 19, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &mDEntrySize(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 19, &val, sizeof(std::int32_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDEntries writer) + { + builder << '{'; + builder << R"("MDEntryPx": )"; + builder << writer.mDEntryPx(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("RptSeq": )"; + builder << +writer.rptSeq(); + + builder << ", "; + builder << R"("OpenCloseSettlFlag": )"; + builder << '"' << writer.openCloseSettlFlag() << '"'; + + builder << ", "; + builder << R"("MDUpdateAction": )"; + builder << '"' << writer.mDUpdateAction() << '"'; + + builder << ", "; + builder << R"("MDEntryType": )"; + builder << '"' << writer.mDEntryType() << '"'; + + builder << ", "; + builder << R"("MDEntrySize": )"; + builder << +writer.mDEntrySize(); + + 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)24); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 24; - 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: + NoMDEntries m_noMDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 24; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDEntriesId() SBE_NOEXCEPT + { + return 268; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDEntries &noMDEntries() + { + m_noMDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDEntries &noMDEntriesCount(const std::uint8_t count) + { + m_noMDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDEntriesSinceVersion() 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 NoMDEntries &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 * - MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT { - return 270; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDEntryPxSinceVersion(); + return m_actingVersion >= noMDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - private: - PRICE m_mDEntryPx; - - public: - SBE_NODISCARD PRICE &mDEntryPx() { - m_mDEntryPx.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_mDEntryPx; - } - - 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 8; - } - - 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 + 8, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoMDEntries &securityID(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 * - RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT { return 83; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - rptSeqSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= rptSeqSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - rptSeqEncodingOffset() SBE_NOEXCEPT { - return 12; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t rptSeq() 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); - } - - NoMDEntries &rptSeq(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 *OpenCloseSettlFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t openCloseSettlFlagId() SBE_NOEXCEPT { - return 286; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - openCloseSettlFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool openCloseSettlFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= openCloseSettlFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - openCloseSettlFlagEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - openCloseSettlFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD OpenCloseSettlFlag::Value - openCloseSettlFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); - return OpenCloseSettlFlag::get((val)); - } - - NoMDEntries & - openCloseSettlFlag(const OpenCloseSettlFlag::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 *MDUpdateActionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT { - return 279; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDUpdateActionSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 17; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint8_t)); - return MDUpdateAction::get((val)); - } - - NoMDEntries & - mDUpdateAction(const MDUpdateAction::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 * - MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT { - return 269; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingOffset() SBE_NOEXCEPT { - return 18; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDEntryTypeStatistics::Value - mDEntryType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 18, sizeof(char)); - return MDEntryTypeStatistics::get((val)); - } - - NoMDEntries & - mDEntryType(const MDEntryTypeStatistics::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 18, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char * - MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT { - return 271; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntrySizeSinceVersion() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntrySizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingOffset() SBE_NOEXCEPT { - return 19; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t mDEntrySize() const SBE_NOEXCEPT { - if (m_actingVersion < 8) { - return 2147483647; - } - - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 19, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoMDEntries &mDEntrySize(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 19, &val, sizeof(std::int32_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDEntries writer) { - builder << '{'; - builder << R"("MDEntryPx": )"; - builder << writer.mDEntryPx(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("RptSeq": )"; - builder << +writer.rptSeq(); - - builder << ", "; - builder << R"("OpenCloseSettlFlag": )"; - builder << '"' << writer.openCloseSettlFlag() << '"'; - - builder << ", "; - builder << R"("MDUpdateAction": )"; - builder << '"' << writer.mDUpdateAction() << '"'; - - builder << ", "; - builder << R"("MDEntryType": )"; - builder << '"' << writer.mDEntryType() << '"'; - - builder << ", "; - builder << R"("MDEntrySize": )"; - builder << +writer.mDEntrySize(); - - builder << '}'; - - return builder; - } - }; - - private: - NoMDEntries m_noMDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDEntriesId() SBE_NOEXCEPT { - return 268; - } - - SBE_NODISCARD inline NoMDEntries &noMDEntries() { - m_noMDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - NoMDEntries &noMDEntriesCount(const std::uint8_t count) { - m_noMDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDIncrementalRefreshSessionStatistics35 _writer) { - MDIncrementalRefreshSessionStatistics35 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDIncrementalRefreshSessionStatistics35", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDEntries": [)"; - writer.noMDEntries().forEach([&](NoMDEntries &noMDEntries) { - if (atLeastOne) { - builder << ", "; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDIncrementalRefreshSessionStatistics35 _writer) +{ + MDIncrementalRefreshSessionStatistics35 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDIncrementalRefreshSessionStatistics35", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDEntries": [)"; + writer.noMDEntries().forEach([&](NoMDEntries& noMDEntries) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDEntries; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noMDEntries().forEach([](NoMDEntries e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t noMDEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoMDEntries::sbeHeaderSize(); + if (noMDEntriesLength > 254LL) + { + throw std::runtime_error("noMDEntriesLength outside of allowed range [E110]"); + } + length += noMDEntriesLength *NoMDEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshSessionStatistics51.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshSessionStatistics51.h index f7603fd2d..f2c4e333f 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshSessionStatistics51.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshSessionStatistics51.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,953 +86,1108 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDIncrementalRefreshSessionStatistics51 { - 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 MDIncrementalRefreshSessionStatistics51 +{ +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; } + 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(11); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(51); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDIncrementalRefreshSessionStatistics51() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDIncrementalRefreshSessionStatistics51( - 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; - MDIncrementalRefreshSessionStatistics51( - char *buffer, const std::uint64_t bufferLength) - : MDIncrementalRefreshSessionStatistics51( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDIncrementalRefreshSessionStatistics51() = default; - MDIncrementalRefreshSessionStatistics51( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDIncrementalRefreshSessionStatistics51( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDIncrementalRefreshSessionStatistics51( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)11; - } + MDIncrementalRefreshSessionStatistics51(char *buffer, const std::uint64_t bufferLength) : + MDIncrementalRefreshSessionStatistics51(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)51; - } + MDIncrementalRefreshSessionStatistics51( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDIncrementalRefreshSessionStatistics51(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(11); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "X"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(51); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDIncrementalRefreshSessionStatistics51 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDIncrementalRefreshSessionStatistics51( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDIncrementalRefreshSessionStatistics51 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "X"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDIncrementalRefreshSessionStatistics51( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDIncrementalRefreshSessionStatistics51 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDIncrementalRefreshSessionStatistics51(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDIncrementalRefreshSessionStatistics51 &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 = MDIncrementalRefreshSessionStatistics51( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDIncrementalRefreshSessionStatistics51 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDIncrementalRefreshSessionStatistics51( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDIncrementalRefreshSessionStatistics51 &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 = MDIncrementalRefreshSessionStatistics51(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MDIncrementalRefreshSessionStatistics51 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + 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(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - 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 + 0, 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MDIncrementalRefreshSessionStatistics51 & - transactTime(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; - } + MDIncrementalRefreshSessionStatistics51 &transactTime(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 *MatchEventIndicatorMetaAttribute( - 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 *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - class NoMDEntries { + class NoMDEntries + { 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(24)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 24; + 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 24; + } + + 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 NoMDEntries &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(static_cast(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 *MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT + { + return 270; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryPxSinceVersion() SBE_NOEXCEPT + { + return 9; + } + + SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICE9 m_mDEntryPx; + +public: + SBE_NODISCARD PRICE9 &mDEntryPx() + { + m_mDEntryPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_mDEntryPx; + } + + 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 8; + } + + 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 + 8, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &securityID(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 *RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT + { + return 83; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t rptSeqSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= rptSeqSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t rptSeqEncodingOffset() SBE_NOEXCEPT + { + return 12; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t rptSeq() 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); + } + + NoMDEntries &rptSeq(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 *OpenCloseSettlFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t openCloseSettlFlagId() SBE_NOEXCEPT + { + return 286; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t openCloseSettlFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool openCloseSettlFlagInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= openCloseSettlFlagSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t openCloseSettlFlagEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t openCloseSettlFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD OpenCloseSettlFlag::Value openCloseSettlFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); + return OpenCloseSettlFlag::get((val)); + } + + NoMDEntries &openCloseSettlFlag(const OpenCloseSettlFlag::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 *MDUpdateActionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT + { + return 279; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDUpdateActionSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 17; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint8_t)); + return MDUpdateAction::get((val)); + } + + NoMDEntries &mDUpdateAction(const MDUpdateAction::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 *MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT + { + return 269; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingOffset() SBE_NOEXCEPT + { + return 18; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDEntryTypeStatistics::Value mDEntryType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 18, sizeof(char)); + return MDEntryTypeStatistics::get((val)); + } + + NoMDEntries &mDEntryType(const MDEntryTypeStatistics::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 18, &val, sizeof(char)); + return *this; + } + + SBE_NODISCARD static const char *MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT + { + return 271; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntrySizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntrySizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingOffset() SBE_NOEXCEPT + { + return 19; + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t mDEntrySize() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 19, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &mDEntrySize(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 19, &val, sizeof(std::int32_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDEntries writer) + { + builder << '{'; + builder << R"("MDEntryPx": )"; + builder << writer.mDEntryPx(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("RptSeq": )"; + builder << +writer.rptSeq(); + + builder << ", "; + builder << R"("OpenCloseSettlFlag": )"; + builder << '"' << writer.openCloseSettlFlag() << '"'; + + builder << ", "; + builder << R"("MDUpdateAction": )"; + builder << '"' << writer.mDUpdateAction() << '"'; + + builder << ", "; + builder << R"("MDEntryType": )"; + builder << '"' << writer.mDEntryType() << '"'; + + builder << ", "; + builder << R"("MDEntrySize": )"; + builder << +writer.mDEntrySize(); + + 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)24); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 24; - 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: + NoMDEntries m_noMDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 24; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDEntriesId() SBE_NOEXCEPT + { + return 268; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDEntries &noMDEntries() + { + m_noMDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDEntries &noMDEntriesCount(const std::uint8_t count) + { + m_noMDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDEntriesSinceVersion() 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 NoMDEntries &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 * - MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT { - return 270; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryPxSinceVersion() SBE_NOEXCEPT { - return 9; - } - - SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDEntryPxSinceVersion(); + return m_actingVersion >= noMDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - private: - PRICE9 m_mDEntryPx; - - public: - SBE_NODISCARD PRICE9 &mDEntryPx() { - m_mDEntryPx.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_mDEntryPx; - } - - 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 8; - } - - 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 + 8, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoMDEntries &securityID(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 * - RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT { return 83; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - rptSeqSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= rptSeqSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - rptSeqEncodingOffset() SBE_NOEXCEPT { - return 12; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t rptSeq() 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); - } - - NoMDEntries &rptSeq(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 *OpenCloseSettlFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t openCloseSettlFlagId() SBE_NOEXCEPT { - return 286; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - openCloseSettlFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool openCloseSettlFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= openCloseSettlFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - openCloseSettlFlagEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - openCloseSettlFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD OpenCloseSettlFlag::Value - openCloseSettlFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::uint8_t)); - return OpenCloseSettlFlag::get((val)); - } - - NoMDEntries & - openCloseSettlFlag(const OpenCloseSettlFlag::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 *MDUpdateActionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT { - return 279; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDUpdateActionSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 17; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint8_t)); - return MDUpdateAction::get((val)); - } - - NoMDEntries & - mDUpdateAction(const MDUpdateAction::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 * - MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT { - return 269; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingOffset() SBE_NOEXCEPT { - return 18; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDEntryTypeStatistics::Value - mDEntryType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 18, sizeof(char)); - return MDEntryTypeStatistics::get((val)); - } - - NoMDEntries & - mDEntryType(const MDEntryTypeStatistics::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 18, &val, sizeof(char)); - return *this; - } - - SBE_NODISCARD static const char * - MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT { - return 271; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntrySizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntrySizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingOffset() SBE_NOEXCEPT { - return 19; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t mDEntrySize() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 19, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoMDEntries &mDEntrySize(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 19, &val, sizeof(std::int32_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDEntries writer) { - builder << '{'; - builder << R"("MDEntryPx": )"; - builder << writer.mDEntryPx(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("RptSeq": )"; - builder << +writer.rptSeq(); - - builder << ", "; - builder << R"("OpenCloseSettlFlag": )"; - builder << '"' << writer.openCloseSettlFlag() << '"'; - - builder << ", "; - builder << R"("MDUpdateAction": )"; - builder << '"' << writer.mDUpdateAction() << '"'; - - builder << ", "; - builder << R"("MDEntryType": )"; - builder << '"' << writer.mDEntryType() << '"'; - - builder << ", "; - builder << R"("MDEntrySize": )"; - builder << +writer.mDEntrySize(); - - builder << '}'; - - return builder; - } - }; - - private: - NoMDEntries m_noMDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDEntriesId() SBE_NOEXCEPT { - return 268; - } - - SBE_NODISCARD inline NoMDEntries &noMDEntries() { - m_noMDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - NoMDEntries &noMDEntriesCount(const std::uint8_t count) { - m_noMDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDIncrementalRefreshSessionStatistics51 _writer) { - MDIncrementalRefreshSessionStatistics51 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDIncrementalRefreshSessionStatistics51", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDEntries": [)"; - writer.noMDEntries().forEach([&](NoMDEntries &noMDEntries) { - if (atLeastOne) { - builder << ", "; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDIncrementalRefreshSessionStatistics51 _writer) +{ + MDIncrementalRefreshSessionStatistics51 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDIncrementalRefreshSessionStatistics51", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDEntries": [)"; + writer.noMDEntries().forEach([&](NoMDEntries& noMDEntries) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDEntries; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noMDEntries().forEach([](NoMDEntries e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t noMDEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoMDEntries::sbeHeaderSize(); + if (noMDEntriesLength > 254LL) + { + throw std::runtime_error("noMDEntriesLength outside of allowed range [E110]"); + } + length += noMDEntriesLength *NoMDEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshTradeSummary42.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshTradeSummary42.h index 067d0dc96..2c6d35750 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshTradeSummary42.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshTradeSummary42.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,1495 +86,1734 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDIncrementalRefreshTradeSummary42 { - 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 MDIncrementalRefreshTradeSummary42 +{ +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; } + 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(11); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(42); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDIncrementalRefreshTradeSummary42() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDIncrementalRefreshTradeSummary42( - 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; - MDIncrementalRefreshTradeSummary42( - char *buffer, const std::uint64_t bufferLength) - : MDIncrementalRefreshTradeSummary42( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDIncrementalRefreshTradeSummary42() = default; - MDIncrementalRefreshTradeSummary42( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDIncrementalRefreshTradeSummary42( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDIncrementalRefreshTradeSummary42( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)11; - } + MDIncrementalRefreshTradeSummary42(char *buffer, const std::uint64_t bufferLength) : + MDIncrementalRefreshTradeSummary42(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)42; - } + MDIncrementalRefreshTradeSummary42( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDIncrementalRefreshTradeSummary42(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(11); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "X"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(42); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDIncrementalRefreshTradeSummary42 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDIncrementalRefreshTradeSummary42( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDIncrementalRefreshTradeSummary42 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "X"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDIncrementalRefreshTradeSummary42( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDIncrementalRefreshTradeSummary42 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDIncrementalRefreshTradeSummary42(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDIncrementalRefreshTradeSummary42 &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 = MDIncrementalRefreshTradeSummary42( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDIncrementalRefreshTradeSummary42 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDIncrementalRefreshTradeSummary42( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDIncrementalRefreshTradeSummary42 &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 = MDIncrementalRefreshTradeSummary42(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 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 * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - 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 0; - } - - 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 + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - MDIncrementalRefreshTradeSummary42 & - transactTime(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 *MatchEventIndicatorMetaAttribute( - 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 matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - private: - MatchEventIndicator m_matchEventIndicator; - - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } - - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } - - class NoMDEntries { - 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)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 { return *m_positionPtr; } - - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), 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; - } + } + 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 + { + MDIncrementalRefreshTradeSummary42 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - inline NoMDEntries &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 *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } -#endif + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } - SBE_NODISCARD static const char * - MDEntryPxMetaAttribute(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 transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint16_t mDEntryPxId() SBE_NOEXCEPT { - return 270; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryPxInActingVersion() 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 >= mDEntryPxSinceVersion(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + MDIncrementalRefreshTradeSummary42 &transactTime(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 *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= matchEventIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + +private: + MatchEventIndicator m_matchEventIndicator; + +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } + + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + class NoMDEntries + { private: - PRICE m_mDEntryPx; + 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 PRICE &mDEntryPx() { - m_mDEntryPx.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_mDEntryPx; - } - - SBE_NODISCARD static const char * - MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT { - return 271; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntrySizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntrySizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t mDEntrySize() 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); - } - - NoMDEntries &mDEntrySize(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 * - 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 12; - } - - 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 + 12, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoMDEntries &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 * - RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT { return 83; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - rptSeqSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= rptSeqSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - rptSeqEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t rptSeq() 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); - } - - NoMDEntries &rptSeq(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 *NumberOfOrdersMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t numberOfOrdersId() SBE_NOEXCEPT { - return 346; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - numberOfOrdersSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool numberOfOrdersInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= numberOfOrdersSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - numberOfOrdersEncodingOffset() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::int32_t numberOfOrdersNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t numberOfOrdersMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t numberOfOrdersMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - numberOfOrdersEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t numberOfOrders() 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); - } - - NoMDEntries &numberOfOrders(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 *AggressorSideMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t aggressorSideId() SBE_NOEXCEPT { - return 5797; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - aggressorSideSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool aggressorSideInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= aggressorSideSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - aggressorSideEncodingOffset() SBE_NOEXCEPT { - return 24; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - aggressorSideEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD AggressorSide::Value aggressorSide() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint8_t)); - return AggressorSide::get((val)); - } - - NoMDEntries & - aggressorSide(const AggressorSide::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *MDUpdateActionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT { - return 279; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDUpdateActionSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 25; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 25, sizeof(std::uint8_t)); - return MDUpdateAction::get((val)); - } - - NoMDEntries & - mDUpdateAction(const MDUpdateAction::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 25, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT { - return 269; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingOffset() SBE_NOEXCEPT { - return 26; - } - - static SBE_CONSTEXPR char mDEntryTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char mDEntryTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char mDEntryTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t mDEntryTypeLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *mDEntryType() const { - static const std::uint8_t mDEntryTypeValues[] = {50}; - - return (const char *)mDEntryTypeValues; - } - - SBE_NODISCARD char mDEntryType(const std::uint64_t index) const { - static const std::uint8_t mDEntryTypeValues[] = {50}; - - return (char)mDEntryTypeValues[index]; - } - - std::uint64_t - getMDEntryType(char *dst, const std::uint64_t length) const { - static std::uint8_t mDEntryTypeValues[] = {50}; - std::uint64_t bytesToCopy = length < sizeof(mDEntryTypeValues) - ? length - : sizeof(mDEntryTypeValues); - - std::memcpy(dst, mDEntryTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getMDEntryTypeAsString() const { - static const std::uint8_t MDEntryTypeValues[] = {50}; - - return std::string((const char *)MDEntryTypeValues, 1); - } - - std::string getMDEntryTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getMDEntryTypeAsString(); - - 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; - } + 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(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; + } - SBE_NODISCARD static const char *MDTradeEntryIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 32; + } - static SBE_CONSTEXPR std::uint16_t mDTradeEntryIDId() SBE_NOEXCEPT { - return 37711; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDTradeEntryIDSinceVersion() SBE_NOEXCEPT { - return 7; - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 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 - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDTradeEntryIDEncodingOffset() SBE_NOEXCEPT { - return 26; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - static SBE_CONSTEXPR std::uint32_t - mDTradeEntryIDNullValue() SBE_NOEXCEPT { - return 4294967295; - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDMinValue() SBE_NOEXCEPT { - return 0; - } + inline NoMDEntries &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; - static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + return *this; + } - static SBE_CONSTEXPR std::size_t - mDTradeEntryIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT + { + 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 std::uint32_t mDTradeEntryID() const SBE_NOEXCEPT { - if (m_actingVersion < 7) { - return 4294967295; - } + #if __cplusplus < 201103L + template inline void forEach(Func& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 26, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + #else + template inline void forEach(Func&& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - NoMDEntries &mDTradeEntryID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 26, &val, sizeof(std::uint32_t)); - return *this; - } + #endif - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDEntries writer) { - builder << '{'; - builder << R"("MDEntryPx": )"; - builder << writer.mDEntryPx(); + SBE_NODISCARD static const char *MDEntryPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("MDEntrySize": )"; - builder << +writer.mDEntrySize(); + static SBE_CONSTEXPR std::uint16_t mDEntryPxId() SBE_NOEXCEPT + { + return 270; + } - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } - builder << ", "; - builder << R"("RptSeq": )"; - builder << +writer.rptSeq(); + SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - builder << ", "; - builder << R"("NumberOfOrders": )"; - builder << +writer.numberOfOrders(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - builder << ", "; - builder << R"("AggressorSide": )"; - builder << '"' << writer.aggressorSide() << '"'; +private: + PRICE m_mDEntryPx; - builder << ", "; - builder << R"("MDUpdateAction": )"; - builder << '"' << writer.mDUpdateAction() << '"'; +public: + SBE_NODISCARD PRICE &mDEntryPx() + { + m_mDEntryPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_mDEntryPx; + } - builder << ", "; - builder << R"("MDTradeEntryID": )"; - builder << +writer.mDTradeEntryID(); + SBE_NODISCARD static const char *MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << '}'; + static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT + { + return 271; + } - return builder; - } - }; + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntrySizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - private: - NoMDEntries m_noMDEntries; + SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntrySizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDEntriesId() SBE_NOEXCEPT { - return 268; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD inline NoMDEntries &noMDEntries() { - m_noMDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } + static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } - NoMDEntries &noMDEntriesCount(const std::uint8_t count) { - m_noMDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } + static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingLength() SBE_NOEXCEPT + { + return 4; + } - class NoOrderIDEntries { - 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::int32_t mDEntrySize() 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); + } - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + NoMDEntries &mDEntrySize(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; + } - public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize8Byte 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 + 8; - } + 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 ""; + } + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + 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 12; + } + + 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 + 12, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &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 *RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT + { + return 83; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t rptSeqSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= rptSeqSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t rptSeqEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t rptSeq() 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); + } + + NoMDEntries &rptSeq(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 *NumberOfOrdersMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t numberOfOrdersId() SBE_NOEXCEPT + { + return 346; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t numberOfOrdersSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool numberOfOrdersInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= numberOfOrdersSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t numberOfOrdersEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::int32_t numberOfOrdersNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t numberOfOrdersMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t numberOfOrdersMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t numberOfOrdersEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t numberOfOrders() 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); + } + + NoMDEntries &numberOfOrders(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 *AggressorSideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t aggressorSideId() SBE_NOEXCEPT + { + return 5797; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t aggressorSideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool aggressorSideInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= aggressorSideSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t aggressorSideEncodingOffset() SBE_NOEXCEPT + { + return 24; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t aggressorSideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD AggressorSide::Value aggressorSide() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint8_t)); + return AggressorSide::get((val)); + } + + NoMDEntries &aggressorSide(const AggressorSide::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *MDUpdateActionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT + { + return 279; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDUpdateActionSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 25; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 25, sizeof(std::uint8_t)); + return MDUpdateAction::get((val)); + } + + NoMDEntries &mDUpdateAction(const MDUpdateAction::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 25, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT + { + return 269; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingOffset() SBE_NOEXCEPT + { + return 26; + } + + static SBE_CONSTEXPR char mDEntryTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char mDEntryTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char mDEntryTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t mDEntryTypeLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *mDEntryType() const + { + static const std::uint8_t mDEntryTypeValues[] = { 50 }; + + return (const char *)mDEntryTypeValues; + } + + SBE_NODISCARD char mDEntryType(const std::uint64_t index) const + { + static const std::uint8_t mDEntryTypeValues[] = { 50 }; + + return (char)mDEntryTypeValues[index]; + } + + std::uint64_t getMDEntryType(char *dst, const std::uint64_t length) const + { + static std::uint8_t mDEntryTypeValues[] = { 50 }; + std::uint64_t bytesToCopy = length < sizeof(mDEntryTypeValues) ? length : sizeof(mDEntryTypeValues); + + std::memcpy(dst, mDEntryTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getMDEntryTypeAsString() const + { + static const std::uint8_t MDEntryTypeValues[] = { 50 }; + + return std::string((const char *)MDEntryTypeValues, 1); + } + + std::string getMDEntryTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getMDEntryTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + 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 *MDTradeEntryIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + 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 7; + } + + 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 26; + } + + static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + 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 + { + if (m_actingVersion < 7) + { + return UINT32_C(0xffffffff); + } + + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 26, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &mDTradeEntryID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 26, &val, sizeof(std::uint32_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDEntries writer) + { + builder << '{'; + builder << R"("MDEntryPx": )"; + builder << writer.mDEntryPx(); + + builder << ", "; + builder << R"("MDEntrySize": )"; + builder << +writer.mDEntrySize(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("RptSeq": )"; + builder << +writer.rptSeq(); + + builder << ", "; + builder << R"("NumberOfOrders": )"; + builder << +writer.numberOfOrders(); + + builder << ", "; + builder << R"("AggressorSide": )"; + builder << '"' << writer.aggressorSide() << '"'; + + builder << ", "; + builder << R"("MDUpdateAction": )"; + builder << '"' << writer.mDUpdateAction() << '"'; + + builder << ", "; + builder << R"("MDTradeEntryID": )"; + builder << +writer.mDTradeEntryID(); + + 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; - GroupSize8Byte dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)16); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 16; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 8; - } + } + }; - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 8; - } +private: + NoMDEntries m_noMDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 16; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDEntriesId() SBE_NOEXCEPT + { + return 268; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDEntries &noMDEntries() + { + m_noMDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDEntries &noMDEntriesCount(const std::uint8_t count) + { + m_noMDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDEntriesSinceVersion() 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 NoOrderIDEntries &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; - GroupSize8Byte 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 * - 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 { + SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= noMDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } + class NoOrderIDEntries + { + 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; - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + public: + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize8Byte 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 + 8; + } - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + 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; + GroupSize8Byte 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 + 8; + } - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() 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); - } + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 16; + } - NoOrderIDEntries &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 std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - SBE_NODISCARD static const char * - LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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::uint16_t lastQtyId() SBE_NOEXCEPT { return 32; } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - SBE_NODISCARD bool lastQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoOrderIDEntries &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; + GroupSize8Byte dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(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 *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 0; + } + + 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoOrderIDEntries &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 *LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + 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 8; + } + + static SBE_CONSTEXPR std::int32_t lastQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t lastQtyMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t lastQtyMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t lastQty() 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); + } + + NoOrderIDEntries &lastQty(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; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoOrderIDEntries writer) + { + builder << '{'; + builder << R"("OrderID": )"; + builder << +writer.orderID(); + + builder << ", "; + builder << R"("LastQty": )"; + builder << +writer.lastQty(); + + 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: + NoOrderIDEntries m_noOrderIDEntries; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoOrderIDEntriesId() SBE_NOEXCEPT + { + return 37705; + } + + SBE_NODISCARD inline NoOrderIDEntries &noOrderIDEntries() + { + m_noOrderIDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderIDEntries; + } + + NoOrderIDEntries &noOrderIDEntriesCount(const std::uint8_t count) + { + m_noOrderIDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderIDEntries; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noOrderIDEntriesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noOrderIDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastQtySinceVersion(); + return m_actingVersion >= noOrderIDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastQtyEncodingOffset() SBE_NOEXCEPT { - return 8; - } +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDIncrementalRefreshTradeSummary42 _writer) +{ + MDIncrementalRefreshTradeSummary42 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDIncrementalRefreshTradeSummary42", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - static SBE_CONSTEXPR std::int32_t lastQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); - static SBE_CONSTEXPR std::int32_t lastQtyMinValue() SBE_NOEXCEPT { - return -2147483647; - } + builder << ", "; + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); - static SBE_CONSTEXPR std::int32_t lastQtyMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t lastQty() 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); - } - - NoOrderIDEntries &lastQty(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; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoOrderIDEntries writer) { - builder << '{'; - builder << R"("OrderID": )"; - builder << +writer.orderID(); - - builder << ", "; - builder << R"("LastQty": )"; - builder << +writer.lastQty(); - - builder << '}'; - - return builder; - } - }; - - private: - NoOrderIDEntries m_noOrderIDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoOrderIDEntriesId() SBE_NOEXCEPT { - return 37705; - } - - SBE_NODISCARD inline NoOrderIDEntries &noOrderIDEntries() { - m_noOrderIDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderIDEntries; - } - - NoOrderIDEntries &noOrderIDEntriesCount(const std::uint8_t count) { - m_noOrderIDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderIDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noOrderIDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noOrderIDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noOrderIDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDIncrementalRefreshTradeSummary42 _writer) { - MDIncrementalRefreshTradeSummary42 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDIncrementalRefreshTradeSummary42", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDEntries": [)"; - writer.noMDEntries().forEach([&](NoMDEntries &noMDEntries) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDEntries": [)"; + writer.noMDEntries().forEach([&](NoMDEntries& noMDEntries) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDEntries; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoOrderIDEntries": [)"; - writer.noOrderIDEntries().forEach( - [&](NoOrderIDEntries &noOrderIDEntries) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noOrderIDEntries; - }); - builder << ']'; - } + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoOrderIDEntries": [)"; + writer.noOrderIDEntries().forEach([&](NoOrderIDEntries& noOrderIDEntries) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noOrderIDEntries; + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noMDEntries().forEach([](NoMDEntries e) + { + e.skip(); + }); + noOrderIDEntries().forEach([](NoOrderIDEntries e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noMDEntriesLength = 0, + std::size_t noOrderIDEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoMDEntries::sbeHeaderSize(); + if (noMDEntriesLength > 254LL) + { + throw std::runtime_error("noMDEntriesLength outside of allowed range [E110]"); + } + length += noMDEntriesLength *NoMDEntries::sbeBlockLength(); + + length += NoOrderIDEntries::sbeHeaderSize(); + if (noOrderIDEntriesLength > 254LL) + { + throw std::runtime_error("noOrderIDEntriesLength outside of allowed range [E110]"); + } + length += noOrderIDEntriesLength *NoOrderIDEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshTradeSummary48.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshTradeSummary48.h index 2799a10d7..42083b632 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshTradeSummary48.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshTradeSummary48.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,1491 +86,1729 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDIncrementalRefreshTradeSummary48 { - 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 MDIncrementalRefreshTradeSummary48 +{ +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; } + 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(11); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(48); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDIncrementalRefreshTradeSummary48() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDIncrementalRefreshTradeSummary48( - 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; - MDIncrementalRefreshTradeSummary48( - char *buffer, const std::uint64_t bufferLength) - : MDIncrementalRefreshTradeSummary48( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDIncrementalRefreshTradeSummary48() = default; - MDIncrementalRefreshTradeSummary48( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDIncrementalRefreshTradeSummary48( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDIncrementalRefreshTradeSummary48( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)11; - } + MDIncrementalRefreshTradeSummary48(char *buffer, const std::uint64_t bufferLength) : + MDIncrementalRefreshTradeSummary48(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)48; - } + MDIncrementalRefreshTradeSummary48( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDIncrementalRefreshTradeSummary48(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(11); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "X"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(48); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDIncrementalRefreshTradeSummary48 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDIncrementalRefreshTradeSummary48( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDIncrementalRefreshTradeSummary48 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "X"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDIncrementalRefreshTradeSummary48( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDIncrementalRefreshTradeSummary48 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDIncrementalRefreshTradeSummary48(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDIncrementalRefreshTradeSummary48 &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 = MDIncrementalRefreshTradeSummary48( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDIncrementalRefreshTradeSummary48 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDIncrementalRefreshTradeSummary48( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDIncrementalRefreshTradeSummary48 &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 = MDIncrementalRefreshTradeSummary48(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 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 * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - 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 0; - } - - 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 + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - MDIncrementalRefreshTradeSummary48 & - transactTime(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 *MatchEventIndicatorMetaAttribute( - 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 matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - private: - MatchEventIndicator m_matchEventIndicator; - - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } - - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } - - class NoMDEntries { - 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)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 { return *m_positionPtr; } - - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), 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; - } + } + 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 + { + MDIncrementalRefreshTradeSummary48 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - inline NoMDEntries &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 *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } -#endif + static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT + { + return 60; + } - SBE_NODISCARD static const char * - MDEntryPxMetaAttribute(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 transactTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint16_t mDEntryPxId() SBE_NOEXCEPT { - return 270; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryPxSinceVersion() SBE_NOEXCEPT { - return 9; - } - - SBE_NODISCARD bool mDEntryPxInActingVersion() 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 >= mDEntryPxSinceVersion(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + MDIncrementalRefreshTradeSummary48 &transactTime(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 *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= matchEventIndicatorSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + +private: + MatchEventIndicator m_matchEventIndicator; + +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } + + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + class NoMDEntries + { private: - PRICE9 m_mDEntryPx; + 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 &mDEntryPx() { - m_mDEntryPx.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_mDEntryPx; - } - - SBE_NODISCARD static const char * - MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT { - return 271; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntrySizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntrySizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t mDEntrySize() 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); - } - - NoMDEntries &mDEntrySize(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 * - 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 12; - } - - 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 + 12, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoMDEntries &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 * - RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT { return 83; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - rptSeqSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= rptSeqSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - rptSeqEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t rptSeq() 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); - } - - NoMDEntries &rptSeq(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 *NumberOfOrdersMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t numberOfOrdersId() SBE_NOEXCEPT { - return 346; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - numberOfOrdersSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool numberOfOrdersInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= numberOfOrdersSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - numberOfOrdersEncodingOffset() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::int32_t numberOfOrdersNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t numberOfOrdersMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t numberOfOrdersMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - numberOfOrdersEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t numberOfOrders() 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); - } - - NoMDEntries &numberOfOrders(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 *AggressorSideMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t aggressorSideId() SBE_NOEXCEPT { - return 5797; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - aggressorSideSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool aggressorSideInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= aggressorSideSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - aggressorSideEncodingOffset() SBE_NOEXCEPT { - return 24; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - aggressorSideEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD AggressorSide::Value aggressorSide() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint8_t)); - return AggressorSide::get((val)); - } - - NoMDEntries & - aggressorSide(const AggressorSide::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char *MDUpdateActionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT { - return 279; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDUpdateActionSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 25; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 25, sizeof(std::uint8_t)); - return MDUpdateAction::get((val)); - } - - NoMDEntries & - mDUpdateAction(const MDUpdateAction::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 25, &val, sizeof(std::uint8_t)); - return *this; - } - - SBE_NODISCARD static const char * - MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT { - return 269; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingOffset() SBE_NOEXCEPT { - return 26; - } - - static SBE_CONSTEXPR char mDEntryTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char mDEntryTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char mDEntryTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t mDEntryTypeLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *mDEntryType() const { - static const std::uint8_t mDEntryTypeValues[] = {50}; - - return (const char *)mDEntryTypeValues; - } - - SBE_NODISCARD char mDEntryType(const std::uint64_t index) const { - static const std::uint8_t mDEntryTypeValues[] = {50}; - - return (char)mDEntryTypeValues[index]; - } - - std::uint64_t - getMDEntryType(char *dst, const std::uint64_t length) const { - static std::uint8_t mDEntryTypeValues[] = {50}; - std::uint64_t bytesToCopy = length < sizeof(mDEntryTypeValues) - ? length - : sizeof(mDEntryTypeValues); - - std::memcpy(dst, mDEntryTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getMDEntryTypeAsString() const { - static const std::uint8_t MDEntryTypeValues[] = {50}; - - return std::string((const char *)MDEntryTypeValues, 1); - } - - std::string getMDEntryTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getMDEntryTypeAsString(); - - 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; - } + 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(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; + } - SBE_NODISCARD static const char *MDTradeEntryIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 32; + } - static SBE_CONSTEXPR std::uint16_t mDTradeEntryIDId() SBE_NOEXCEPT { - return 37711; - } + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDTradeEntryIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 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 - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDTradeEntryIDEncodingOffset() SBE_NOEXCEPT { - return 26; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - static SBE_CONSTEXPR std::uint32_t - mDTradeEntryIDNullValue() SBE_NOEXCEPT { - return 4294967295; - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDMinValue() SBE_NOEXCEPT { - return 0; - } + inline NoMDEntries &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; - static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + return *this; + } - static SBE_CONSTEXPR std::size_t - mDTradeEntryIDEncodingLength() SBE_NOEXCEPT { - return 4; - } + inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT + { + 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 std::uint32_t mDTradeEntryID() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 26, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + #if __cplusplus < 201103L + template inline void forEach(Func& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - NoMDEntries &mDTradeEntryID(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 26, &val, sizeof(std::uint32_t)); - return *this; - } + #else + template inline void forEach(Func&& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDEntries writer) { - builder << '{'; - builder << R"("MDEntryPx": )"; - builder << writer.mDEntryPx(); + #endif - builder << ", "; - builder << R"("MDEntrySize": )"; - builder << +writer.mDEntrySize(); + SBE_NODISCARD static const char *MDEntryPxMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Price"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + static SBE_CONSTEXPR std::uint16_t mDEntryPxId() SBE_NOEXCEPT + { + return 270; + } - builder << ", "; - builder << R"("RptSeq": )"; - builder << +writer.rptSeq(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryPxSinceVersion() SBE_NOEXCEPT + { + return 9; + } - builder << ", "; - builder << R"("NumberOfOrders": )"; - builder << +writer.numberOfOrders(); + SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - builder << ", "; - builder << R"("AggressorSide": )"; - builder << '"' << writer.aggressorSide() << '"'; + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - builder << ", "; - builder << R"("MDUpdateAction": )"; - builder << '"' << writer.mDUpdateAction() << '"'; +private: + PRICE9 m_mDEntryPx; - builder << ", "; - builder << R"("MDTradeEntryID": )"; - builder << +writer.mDTradeEntryID(); +public: + SBE_NODISCARD PRICE9 &mDEntryPx() + { + m_mDEntryPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_mDEntryPx; + } - builder << '}'; + SBE_NODISCARD static const char *MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - return builder; - } - }; + static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT + { + return 271; + } - private: - NoMDEntries m_noMDEntries; + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntrySizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDEntriesId() SBE_NOEXCEPT { - return 268; - } + SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntrySizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - SBE_NODISCARD inline NoMDEntries &noMDEntries() { - m_noMDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - NoMDEntries &noMDEntriesCount(const std::uint8_t count) { - m_noMDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } + static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - class NoOrderIDEntries { - 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; + static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + SBE_NODISCARD std::int32_t mDEntrySize() 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); + } - public: - inline void wrapForDecode( - char *buffer, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - GroupSize8Byte 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 + 8; - } + NoMDEntries &mDEntrySize(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 void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + 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 12; + } + + 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 + 12, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &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 *RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT + { + return 83; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t rptSeqSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= rptSeqSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t rptSeqEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t rptSeq() 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); + } + + NoMDEntries &rptSeq(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 *NumberOfOrdersMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t numberOfOrdersId() SBE_NOEXCEPT + { + return 346; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t numberOfOrdersSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool numberOfOrdersInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= numberOfOrdersSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t numberOfOrdersEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::int32_t numberOfOrdersNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t numberOfOrdersMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t numberOfOrdersMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t numberOfOrdersEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t numberOfOrders() 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); + } + + NoMDEntries &numberOfOrders(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 *AggressorSideMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t aggressorSideId() SBE_NOEXCEPT + { + return 5797; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t aggressorSideSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool aggressorSideInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= aggressorSideSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t aggressorSideEncodingOffset() SBE_NOEXCEPT + { + return 24; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t aggressorSideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD AggressorSide::Value aggressorSide() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint8_t)); + return AggressorSide::get((val)); + } + + NoMDEntries &aggressorSide(const AggressorSide::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *MDUpdateActionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT + { + return 279; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDUpdateActionSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 25; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 25, sizeof(std::uint8_t)); + return MDUpdateAction::get((val)); + } + + NoMDEntries &mDUpdateAction(const MDUpdateAction::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 25, &val, sizeof(std::uint8_t)); + return *this; + } + + SBE_NODISCARD static const char *MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT + { + return 269; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingOffset() SBE_NOEXCEPT + { + return 26; + } + + static SBE_CONSTEXPR char mDEntryTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char mDEntryTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char mDEntryTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t mDEntryTypeLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *mDEntryType() const + { + static const std::uint8_t mDEntryTypeValues[] = { 50 }; + + return (const char *)mDEntryTypeValues; + } + + SBE_NODISCARD char mDEntryType(const std::uint64_t index) const + { + static const std::uint8_t mDEntryTypeValues[] = { 50 }; + + return (char)mDEntryTypeValues[index]; + } + + std::uint64_t getMDEntryType(char *dst, const std::uint64_t length) const + { + static std::uint8_t mDEntryTypeValues[] = { 50 }; + std::uint64_t bytesToCopy = length < sizeof(mDEntryTypeValues) ? length : sizeof(mDEntryTypeValues); + + std::memcpy(dst, mDEntryTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getMDEntryTypeAsString() const + { + static const std::uint8_t MDEntryTypeValues[] = { 50 }; + + return std::string((const char *)MDEntryTypeValues, 1); + } + + std::string getMDEntryTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getMDEntryTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + 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 *MDTradeEntryIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + 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 26; + } + + static SBE_CONSTEXPR std::uint32_t mDTradeEntryIDNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } + + 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 + 26, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &mDTradeEntryID(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 26, &val, sizeof(std::uint32_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDEntries writer) + { + builder << '{'; + builder << R"("MDEntryPx": )"; + builder << writer.mDEntryPx(); + + builder << ", "; + builder << R"("MDEntrySize": )"; + builder << +writer.mDEntrySize(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("RptSeq": )"; + builder << +writer.rptSeq(); + + builder << ", "; + builder << R"("NumberOfOrders": )"; + builder << +writer.numberOfOrders(); + + builder << ", "; + builder << R"("AggressorSide": )"; + builder << '"' << writer.aggressorSide() << '"'; + + builder << ", "; + builder << R"("MDUpdateAction": )"; + builder << '"' << writer.mDUpdateAction() << '"'; + + builder << ", "; + builder << R"("MDTradeEntryID": )"; + builder << +writer.mDTradeEntryID(); + + 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; - GroupSize8Byte dimensions(buffer, *pos, bufferLength, actingVersion); - dimensions.blockLength((std::uint16_t)16); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 16; - m_actingVersion = actingVersion; - m_initialPosition = *pos; - m_positionPtr = pos; - *m_positionPtr = *m_positionPtr + 8; - } + } + }; - static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT { - return 8; - } +private: + NoMDEntries m_noMDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 16; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDEntriesId() SBE_NOEXCEPT + { + return 268; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDEntries &noMDEntries() + { + m_noMDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDEntries &noMDEntriesCount(const std::uint8_t count) + { + m_noMDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDEntriesSinceVersion() 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 NoOrderIDEntries &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; - GroupSize8Byte 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 * - 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 { + SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= noMDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - orderIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } + class NoOrderIDEntries + { + 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; - static SBE_CONSTEXPR std::uint64_t orderIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } - static SBE_CONSTEXPR std::uint64_t orderIDMinValue() SBE_NOEXCEPT { - return 0x0L; - } + public: + inline void wrapForDecode( + char *buffer, + std::uint64_t *pos, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + GroupSize8Byte 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 + 8; + } - static SBE_CONSTEXPR std::uint64_t orderIDMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + 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; + GroupSize8Byte 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 + 8; + } - static SBE_CONSTEXPR std::size_t orderIDEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() 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); - } + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 16; + } - NoOrderIDEntries &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 std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - SBE_NODISCARD static const char * - LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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::uint16_t lastQtyId() SBE_NOEXCEPT { return 32; } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - SBE_NODISCARD bool lastQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } + + inline NoOrderIDEntries &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; + GroupSize8Byte dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(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 *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 0; + } + + 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoOrderIDEntries &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 *LastQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + 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 8; + } + + static SBE_CONSTEXPR std::int32_t lastQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t lastQtyMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t lastQtyMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t lastQty() 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); + } + + NoOrderIDEntries &lastQty(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; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoOrderIDEntries writer) + { + builder << '{'; + builder << R"("OrderID": )"; + builder << +writer.orderID(); + + builder << ", "; + builder << R"("LastQty": )"; + builder << +writer.lastQty(); + + 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: + NoOrderIDEntries m_noOrderIDEntries; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoOrderIDEntriesId() SBE_NOEXCEPT + { + return 37705; + } + + SBE_NODISCARD inline NoOrderIDEntries &noOrderIDEntries() + { + m_noOrderIDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderIDEntries; + } + + NoOrderIDEntries &noOrderIDEntriesCount(const std::uint8_t count) + { + m_noOrderIDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noOrderIDEntries; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noOrderIDEntriesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noOrderIDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastQtySinceVersion(); + return m_actingVersion >= noOrderIDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastQtyEncodingOffset() SBE_NOEXCEPT { - return 8; - } +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDIncrementalRefreshTradeSummary48 _writer) +{ + MDIncrementalRefreshTradeSummary48 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDIncrementalRefreshTradeSummary48", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - static SBE_CONSTEXPR std::int32_t lastQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); - static SBE_CONSTEXPR std::int32_t lastQtyMinValue() SBE_NOEXCEPT { - return -2147483647; - } + builder << ", "; + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); - static SBE_CONSTEXPR std::int32_t lastQtyMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t lastQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t lastQty() 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); - } - - NoOrderIDEntries &lastQty(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; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoOrderIDEntries writer) { - builder << '{'; - builder << R"("OrderID": )"; - builder << +writer.orderID(); - - builder << ", "; - builder << R"("LastQty": )"; - builder << +writer.lastQty(); - - builder << '}'; - - return builder; - } - }; - - private: - NoOrderIDEntries m_noOrderIDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoOrderIDEntriesId() SBE_NOEXCEPT { - return 37705; - } - - SBE_NODISCARD inline NoOrderIDEntries &noOrderIDEntries() { - m_noOrderIDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderIDEntries; - } - - NoOrderIDEntries &noOrderIDEntriesCount(const std::uint8_t count) { - m_noOrderIDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noOrderIDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noOrderIDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noOrderIDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noOrderIDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDIncrementalRefreshTradeSummary48 _writer) { - MDIncrementalRefreshTradeSummary48 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDIncrementalRefreshTradeSummary48", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDEntries": [)"; - writer.noMDEntries().forEach([&](NoMDEntries &noMDEntries) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDEntries": [)"; + writer.noMDEntries().forEach([&](NoMDEntries& noMDEntries) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDEntries; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoOrderIDEntries": [)"; - writer.noOrderIDEntries().forEach( - [&](NoOrderIDEntries &noOrderIDEntries) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noOrderIDEntries; - }); - builder << ']'; - } + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoOrderIDEntries": [)"; + writer.noOrderIDEntries().forEach([&](NoOrderIDEntries& noOrderIDEntries) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noOrderIDEntries; + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noMDEntries().forEach([](NoMDEntries e) + { + e.skip(); + }); + noOrderIDEntries().forEach([](NoOrderIDEntries e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noMDEntriesLength = 0, + std::size_t noOrderIDEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoMDEntries::sbeHeaderSize(); + if (noMDEntriesLength > 254LL) + { + throw std::runtime_error("noMDEntriesLength outside of allowed range [E110]"); + } + length += noMDEntriesLength *NoMDEntries::sbeBlockLength(); + + length += NoOrderIDEntries::sbeHeaderSize(); + if (noOrderIDEntriesLength > 254LL) + { + throw std::runtime_error("noOrderIDEntriesLength outside of allowed range [E110]"); + } + length += noOrderIDEntriesLength *NoOrderIDEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshVolume37.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshVolume37.h index c6bdfb710..23538067a 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshVolume37.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDIncrementalRefreshVolume37.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,909 +86,1062 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDIncrementalRefreshVolume37 { - 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 MDIncrementalRefreshVolume37 +{ +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; } + 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(11); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(37); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDIncrementalRefreshVolume37() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDIncrementalRefreshVolume37( - 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; - MDIncrementalRefreshVolume37(char *buffer, const std::uint64_t bufferLength) - : MDIncrementalRefreshVolume37( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDIncrementalRefreshVolume37() = default; - MDIncrementalRefreshVolume37( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDIncrementalRefreshVolume37( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDIncrementalRefreshVolume37( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)11; - } + MDIncrementalRefreshVolume37(char *buffer, const std::uint64_t bufferLength) : + MDIncrementalRefreshVolume37(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)37; - } + MDIncrementalRefreshVolume37( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDIncrementalRefreshVolume37(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(11); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "X"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(37); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDIncrementalRefreshVolume37 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDIncrementalRefreshVolume37( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDIncrementalRefreshVolume37 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "X"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDIncrementalRefreshVolume37( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDIncrementalRefreshVolume37 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDIncrementalRefreshVolume37(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDIncrementalRefreshVolume37 &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 = MDIncrementalRefreshVolume37( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDIncrementalRefreshVolume37 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDIncrementalRefreshVolume37( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDIncrementalRefreshVolume37 &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 = MDIncrementalRefreshVolume37(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MDIncrementalRefreshVolume37 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + 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(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - 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 + 0, 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MDIncrementalRefreshVolume37 & - transactTime(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; - } + MDIncrementalRefreshVolume37 &transactTime(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 *MatchEventIndicatorMetaAttribute( - 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 *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 8, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - class NoMDEntries { + class NoMDEntries + { 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(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; + } + + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 16; + } + + 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 NoMDEntries &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(static_cast(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 *MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT + { + return 271; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntrySizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntrySizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t mDEntrySize() 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); + } + + NoMDEntries &mDEntrySize(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 *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); + } + + NoMDEntries &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 *RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT + { + return 83; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t rptSeqSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= rptSeqSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t rptSeqEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } + + static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } + + static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::uint32_t rptSeq() 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); + } + + NoMDEntries &rptSeq(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 *MDUpdateActionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT + { + return 279; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDUpdateActionSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 12; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 12, sizeof(std::uint8_t)); + return MDUpdateAction::get((val)); + } + + NoMDEntries &mDUpdateAction(const MDUpdateAction::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 static const char *MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT + { + return 269; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingOffset() SBE_NOEXCEPT + { + return 13; + } + + static SBE_CONSTEXPR char mDEntryTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char mDEntryTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char mDEntryTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t mDEntryTypeLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *mDEntryType() const + { + static const std::uint8_t mDEntryTypeValues[] = { 101 }; + + return (const char *)mDEntryTypeValues; + } + + SBE_NODISCARD char mDEntryType(const std::uint64_t index) const + { + static const std::uint8_t mDEntryTypeValues[] = { 101 }; + + return (char)mDEntryTypeValues[index]; + } + + std::uint64_t getMDEntryType(char *dst, const std::uint64_t length) const + { + static std::uint8_t mDEntryTypeValues[] = { 101 }; + std::uint64_t bytesToCopy = length < sizeof(mDEntryTypeValues) ? length : sizeof(mDEntryTypeValues); + + std::memcpy(dst, mDEntryTypeValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getMDEntryTypeAsString() const + { + static const std::uint8_t MDEntryTypeValues[] = { 101 }; + + return std::string((const char *)MDEntryTypeValues, 1); + } + + std::string getMDEntryTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getMDEntryTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + default: + if ('\x00' <= c && c <= '\x1f') + { + oss << "\\u" << std::hex << std::setw(4) + << std::setfill('0') << (int)(c); + } + else + { + oss << c; + } + } + } + + return oss.str(); + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDEntries writer) + { + builder << '{'; + builder << R"("MDEntrySize": )"; + builder << +writer.mDEntrySize(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("RptSeq": )"; + builder << +writer.rptSeq(); + + builder << ", "; + builder << R"("MDUpdateAction": )"; + builder << '"' << writer.mDUpdateAction() << '"'; + + 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)16); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 16; - 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: + NoMDEntries m_noMDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 16; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDEntriesId() SBE_NOEXCEPT + { + return 268; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDEntries &noMDEntries() + { + m_noMDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDEntries &noMDEntriesCount(const std::uint8_t count) + { + m_noMDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDEntriesSinceVersion() 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 NoMDEntries &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 * - MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT { - return 271; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntrySizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDEntrySizeSinceVersion(); + return m_actingVersion >= noMDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t mDEntrySize() 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); - } - - NoMDEntries &mDEntrySize(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 * - 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); - } - - NoMDEntries &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 * - RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT { return 83; } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - rptSeqSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= rptSeqSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - rptSeqEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT { - return 4294967294; - } - - static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::uint32_t rptSeq() 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); - } - - NoMDEntries &rptSeq(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 *MDUpdateActionMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDUpdateActionId() SBE_NOEXCEPT { - return 279; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDUpdateActionInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDUpdateActionSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 12; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDUpdateAction::Value mDUpdateAction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 12, sizeof(std::uint8_t)); - return MDUpdateAction::get((val)); - } - - NoMDEntries & - mDUpdateAction(const MDUpdateAction::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 static const char * - MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT { - return 269; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingOffset() SBE_NOEXCEPT { - return 13; - } - - static SBE_CONSTEXPR char mDEntryTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char mDEntryTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char mDEntryTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t mDEntryTypeLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *mDEntryType() const { - static const std::uint8_t mDEntryTypeValues[] = {101}; - - return (const char *)mDEntryTypeValues; - } - - SBE_NODISCARD char mDEntryType(const std::uint64_t index) const { - static const std::uint8_t mDEntryTypeValues[] = {101}; - - return (char)mDEntryTypeValues[index]; - } - - std::uint64_t - getMDEntryType(char *dst, const std::uint64_t length) const { - static std::uint8_t mDEntryTypeValues[] = {101}; - std::uint64_t bytesToCopy = length < sizeof(mDEntryTypeValues) - ? length - : sizeof(mDEntryTypeValues); - - std::memcpy(dst, mDEntryTypeValues, static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getMDEntryTypeAsString() const { - static const std::uint8_t MDEntryTypeValues[] = {101}; - - return std::string((const char *)MDEntryTypeValues, 1); - } - - std::string getMDEntryTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getMDEntryTypeAsString(); - - 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(); - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDEntries writer) { - builder << '{'; - builder << R"("MDEntrySize": )"; - builder << +writer.mDEntrySize(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("RptSeq": )"; - builder << +writer.rptSeq(); - - builder << ", "; - builder << R"("MDUpdateAction": )"; - builder << '"' << writer.mDUpdateAction() << '"'; - - builder << '}'; - - return builder; - } - }; - - private: - NoMDEntries m_noMDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDEntriesId() SBE_NOEXCEPT { - return 268; - } - - SBE_NODISCARD inline NoMDEntries &noMDEntries() { - m_noMDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - NoMDEntries &noMDEntriesCount(const std::uint8_t count) { - m_noMDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDIncrementalRefreshVolume37 _writer) { - MDIncrementalRefreshVolume37 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDIncrementalRefreshVolume37", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDEntries": [)"; - writer.noMDEntries().forEach([&](NoMDEntries &noMDEntries) { - if (atLeastOne) { - builder << ", "; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDIncrementalRefreshVolume37 _writer) +{ + MDIncrementalRefreshVolume37 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDIncrementalRefreshVolume37", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDEntries": [)"; + writer.noMDEntries().forEach([&](NoMDEntries& noMDEntries) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDEntries; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noMDEntries().forEach([](NoMDEntries e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t noMDEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoMDEntries::sbeHeaderSize(); + if (noMDEntriesLength > 254LL) + { + throw std::runtime_error("noMDEntriesLength outside of allowed range [E110]"); + } + length += noMDEntriesLength *NoMDEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionFuture27.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionFuture27.h index 24fd9bf3d..1d362ac19 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionFuture27.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionFuture27.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,5889 +86,6404 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDInstrumentDefinitionFuture27 { - 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 MDInstrumentDefinitionFuture27 +{ +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; } + 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(216); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(27); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDInstrumentDefinitionFuture27() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDInstrumentDefinitionFuture27( - 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; - MDInstrumentDefinitionFuture27( - char *buffer, const std::uint64_t bufferLength) - : MDInstrumentDefinitionFuture27( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDInstrumentDefinitionFuture27() = default; - MDInstrumentDefinitionFuture27( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDInstrumentDefinitionFuture27( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDInstrumentDefinitionFuture27( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)216; - } + MDInstrumentDefinitionFuture27(char *buffer, const std::uint64_t bufferLength) : + MDInstrumentDefinitionFuture27(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)27; - } + MDInstrumentDefinitionFuture27( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDInstrumentDefinitionFuture27(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(216); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "d"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(27); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDInstrumentDefinitionFuture27 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDInstrumentDefinitionFuture27( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDInstrumentDefinitionFuture27 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "d"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDInstrumentDefinitionFuture27( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDInstrumentDefinitionFuture27 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDInstrumentDefinitionFuture27(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDInstrumentDefinitionFuture27 &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 = MDInstrumentDefinitionFuture27( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDInstrumentDefinitionFuture27 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDInstrumentDefinitionFuture27( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDInstrumentDefinitionFuture27 &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 = MDInstrumentDefinitionFuture27(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MDInstrumentDefinitionFuture27 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char *MatchEventIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MultipleCharValue"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char * - TotNumReportsMetaAttribute(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 *TotNumReportsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT { - return 911; - } + static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT + { + return 911; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totNumReportsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t totNumReportsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= totNumReportsSinceVersion(); + return m_actingVersion >= totNumReportsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totNumReportsEncodingOffset() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t totNumReportsEncodingOffset() SBE_NOEXCEPT + { + return 1; + } - static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t totNumReports() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t totNumReports() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionFuture27 & - totNumReports(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint32_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &totNumReports(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char *SecurityUpdateActionMetaAttribute( - 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 *SecurityUpdateActionMetaAttribute(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 securityUpdateActionId() SBE_NOEXCEPT { - return 980; - } + static SBE_CONSTEXPR std::uint16_t securityUpdateActionId() SBE_NOEXCEPT + { + return 980; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityUpdateActionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityUpdateActionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityUpdateActionSinceVersion(); + return m_actingVersion >= securityUpdateActionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SecurityUpdateAction::Value - securityUpdateAction() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 5, sizeof(char)); - return SecurityUpdateAction::get((val)); - } + SBE_NODISCARD SecurityUpdateAction::Value securityUpdateAction() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 5, sizeof(char)); + return SecurityUpdateAction::get((val)); + } - MDInstrumentDefinitionFuture27 & - securityUpdateAction(const SecurityUpdateAction::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 5, &val, sizeof(char)); - return *this; - } + MDInstrumentDefinitionFuture27 &securityUpdateAction(const SecurityUpdateAction::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 5, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char * - LastUpdateTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LastUpdateTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t lastUpdateTimeId() SBE_NOEXCEPT { - return 779; - } + static SBE_CONSTEXPR std::uint16_t lastUpdateTimeId() SBE_NOEXCEPT + { + return 779; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastUpdateTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastUpdateTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lastUpdateTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lastUpdateTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastUpdateTimeSinceVersion(); + return m_actingVersion >= lastUpdateTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastUpdateTimeEncodingOffset() SBE_NOEXCEPT { - return 6; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastUpdateTimeEncodingOffset() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - lastUpdateTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t lastUpdateTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t lastUpdateTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 6, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t lastUpdateTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 6, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MDInstrumentDefinitionFuture27 & - lastUpdateTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 6, &val, sizeof(std::uint64_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &lastUpdateTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 6, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *MDSecurityTradingStatusMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MDSecurityTradingStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mDSecurityTradingStatusId() SBE_NOEXCEPT { - return 1682; - } + static SBE_CONSTEXPR std::uint16_t mDSecurityTradingStatusId() SBE_NOEXCEPT + { + return 1682; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDSecurityTradingStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDSecurityTradingStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mDSecurityTradingStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mDSecurityTradingStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDSecurityTradingStatusSinceVersion(); + return m_actingVersion >= mDSecurityTradingStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDSecurityTradingStatusEncodingOffset() SBE_NOEXCEPT { - return 14; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDSecurityTradingStatusEncodingOffset() SBE_NOEXCEPT + { + return 14; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDSecurityTradingStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDSecurityTradingStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SecurityTradingStatus::Value - mDSecurityTradingStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); - return SecurityTradingStatus::get((val)); - } + SBE_NODISCARD SecurityTradingStatus::Value mDSecurityTradingStatus() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); + return SecurityTradingStatus::get((val)); + } - MDInstrumentDefinitionFuture27 &mDSecurityTradingStatus( - const SecurityTradingStatus::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &mDSecurityTradingStatus(const SecurityTradingStatus::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - ApplIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ApplIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t applIDId() SBE_NOEXCEPT { return 1180; } + static SBE_CONSTEXPR std::uint16_t applIDId() SBE_NOEXCEPT + { + return 1180; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - applIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t applIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool applIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool applIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= applIDSinceVersion(); + return m_actingVersion >= applIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - applIDEncodingOffset() SBE_NOEXCEPT { - return 15; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t applIDEncodingOffset() SBE_NOEXCEPT + { + return 15; + } - static SBE_CONSTEXPR std::int16_t applIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT16; - } + static SBE_CONSTEXPR std::int16_t applIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT16; + } - static SBE_CONSTEXPR std::int16_t applIDMinValue() SBE_NOEXCEPT { - return (std::int16_t)-32767; - } + static SBE_CONSTEXPR std::int16_t applIDMinValue() SBE_NOEXCEPT + { + return static_cast(-32767); + } - static SBE_CONSTEXPR std::int16_t applIDMaxValue() SBE_NOEXCEPT { - return (std::int16_t)32767; - } + static SBE_CONSTEXPR std::int16_t applIDMaxValue() SBE_NOEXCEPT + { + return static_cast(32767); + } - static SBE_CONSTEXPR std::size_t applIDEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t applIDEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::int16_t applID() const SBE_NOEXCEPT { - std::int16_t val; - std::memcpy(&val, m_buffer + m_offset + 15, sizeof(std::int16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::int16_t applID() const SBE_NOEXCEPT + { + std::int16_t val; + std::memcpy(&val, m_buffer + m_offset + 15, sizeof(std::int16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - MDInstrumentDefinitionFuture27 & - applID(const std::int16_t value) SBE_NOEXCEPT { - std::int16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 15, &val, sizeof(std::int16_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &applID(const std::int16_t value) SBE_NOEXCEPT + { + std::int16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 15, &val, sizeof(std::int16_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 "required"; - 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 "required"; + 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 17; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t marketSegmentIDEncodingOffset() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } - 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 + 17, 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 + 17, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionFuture27 & - marketSegmentID(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &marketSegmentID(const std::uint8_t 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 *UnderlyingProductMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UnderlyingProductMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t underlyingProductId() SBE_NOEXCEPT { - return 462; - } + static SBE_CONSTEXPR std::uint16_t underlyingProductId() SBE_NOEXCEPT + { + return 462; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - underlyingProductSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t underlyingProductSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool underlyingProductInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool underlyingProductInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= underlyingProductSinceVersion(); + return m_actingVersion >= underlyingProductSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - underlyingProductEncodingOffset() SBE_NOEXCEPT { - return 18; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t underlyingProductEncodingOffset() SBE_NOEXCEPT + { + return 18; + } - static SBE_CONSTEXPR std::uint8_t underlyingProductNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR std::uint8_t underlyingProductNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } - static SBE_CONSTEXPR std::uint8_t underlyingProductMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t underlyingProductMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t underlyingProductMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t underlyingProductMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - underlyingProductEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t underlyingProductEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t underlyingProduct() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t underlyingProduct() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionFuture27 & - underlyingProduct(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; - } + MDInstrumentDefinitionFuture27 &underlyingProduct(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 static const char *SecurityExchangeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Exchange"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityExchangeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Exchange"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityExchangeId() SBE_NOEXCEPT { - return 207; - } + static SBE_CONSTEXPR std::uint16_t securityExchangeId() SBE_NOEXCEPT + { + return 207; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityExchangeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityExchangeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityExchangeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityExchangeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityExchangeSinceVersion(); + return m_actingVersion >= securityExchangeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityExchangeEncodingOffset() SBE_NOEXCEPT { - return 19; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityExchangeEncodingOffset() SBE_NOEXCEPT + { + return 19; + } - static SBE_CONSTEXPR char securityExchangeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityExchangeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityExchangeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityExchangeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityExchangeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char securityExchangeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - securityExchangeEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityExchangeEncodingLength() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t securityExchangeLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::uint64_t securityExchangeLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD const char *securityExchange() const SBE_NOEXCEPT { - return m_buffer + m_offset + 19; - } + SBE_NODISCARD const char *securityExchange() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 19; + } - SBE_NODISCARD char *securityExchange() SBE_NOEXCEPT { - return m_buffer + m_offset + 19; - } + SBE_NODISCARD char *securityExchange() SBE_NOEXCEPT + { + return m_buffer + m_offset + 19; + } - SBE_NODISCARD char securityExchange(const std::uint64_t index) const { - if (index >= 4) { - throw std::runtime_error( - "index out of range for securityExchange [E104]"); - } + SBE_NODISCARD char securityExchange(const std::uint64_t index) const + { + if (index >= 4) + { + throw std::runtime_error("index out of range for securityExchange [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 19 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 19 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture27 & - securityExchange(const std::uint64_t index, const char value) { - if (index >= 4) { - throw std::runtime_error( - "index out of range for securityExchange [E105]"); - } + MDInstrumentDefinitionFuture27 &securityExchange(const std::uint64_t index, const char value) + { + if (index >= 4) + { + throw std::runtime_error("index out of range for securityExchange [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 19 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 19 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSecurityExchange(char *const dst, const std::uint64_t length) const { - if (length > 4) { - throw std::runtime_error( - "length too large for getSecurityExchange [E106]"); - } + std::uint64_t getSecurityExchange(char *const dst, const std::uint64_t length) const + { + if (length > 4) + { + throw std::runtime_error("length too large for getSecurityExchange [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 19, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 19, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionFuture27 & - putSecurityExchange(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 19, src, sizeof(char) * 4); - return *this; - } + MDInstrumentDefinitionFuture27 &putSecurityExchange(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 19, src, sizeof(char) * 4); + return *this; + } - MDInstrumentDefinitionFuture27 &putSecurityExchange( - const char value0, - const char value1, - const char value2, - const char value3) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 19, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 20, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 21, &val2, sizeof(char)); - char val3 = (value3); - std::memcpy(m_buffer + m_offset + 22, &val3, sizeof(char)); + MDInstrumentDefinitionFuture27 &putSecurityExchange( + const char value0, + const char value1, + const char value2, + const char value3) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 19, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 20, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 21, &val2, sizeof(char)); + char val3 = (value3); + std::memcpy(m_buffer + m_offset + 22, &val3, sizeof(char)); - return *this; - } + return *this; + } - std::string getSecurityExchangeAsString() const { - const char *buffer = m_buffer + m_offset + 19; - size_t length = 0; + SBE_NODISCARD std::string getSecurityExchangeAsString() const + { + const char *buffer = m_buffer + m_offset + 19; + size_t length = 0; - for (; length < 4 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 4 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSecurityExchangeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityExchangeAsString(); + std::string getSecurityExchangeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityExchangeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityExchangeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 19; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityExchangeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 19; + size_t length = 0; - for (; length < 4 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 4 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - MDInstrumentDefinitionFuture27 & - putSecurityExchange(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 4) { - throw std::runtime_error( - "string too large for putSecurityExchange [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionFuture27 &putSecurityExchange(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 4) + { + throw std::runtime_error("string too large for putSecurityExchange [E106]"); + } - std::memcpy(m_buffer + m_offset + 19, str.data(), srcLength); - for (size_t start = srcLength; start < 4; ++start) { - m_buffer[m_offset + 19 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 19, str.data(), srcLength); + for (size_t start = srcLength; start < 4; ++start) + { + m_buffer[m_offset + 19 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionFuture27 &putSecurityExchange(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 4) { - throw std::runtime_error( - "string too large for putSecurityExchange [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionFuture27 &putSecurityExchange(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 4) + { + throw std::runtime_error("string too large for putSecurityExchange [E106]"); + } - std::memcpy(m_buffer + m_offset + 19, str.c_str(), srcLength); - for (size_t start = srcLength; start < 4; ++start) { - m_buffer[m_offset + 19 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 19, str.c_str(), srcLength); + for (size_t start = srcLength; start < 4; ++start) + { + m_buffer[m_offset + 19 + start] = 0; + } - return *this; - } -#endif + return *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 "required"; - 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 "required"; + 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 23; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityGroupEncodingOffset() SBE_NOEXCEPT + { + return 23; + } - 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 + 23; - } + SBE_NODISCARD const char *securityGroup() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 23; + } - SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT { - return m_buffer + m_offset + 23; - } + SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT + { + return m_buffer + m_offset + 23; + } - 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 + 23 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 23 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture27 & - securityGroup(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E105]"); - } + MDInstrumentDefinitionFuture27 &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 + 23 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 23 + (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 + 23, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 23, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionFuture27 & - putSecurityGroup(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 23, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionFuture27 &putSecurityGroup(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 23, src, sizeof(char) * 6); + return *this; + } - std::string getSecurityGroupAsString() const { - const char *buffer = m_buffer + m_offset + 23; - size_t length = 0; + SBE_NODISCARD std::string getSecurityGroupAsString() const + { + const char *buffer = m_buffer + m_offset + 23; + 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 (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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityGroupAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 23; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 23; + 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 - MDInstrumentDefinitionFuture27 & - 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 + MDInstrumentDefinitionFuture27 &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 + 23, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 23 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 23, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 23 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionFuture27 &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 + MDInstrumentDefinitionFuture27 &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 + 23, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 23 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 23, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 23 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - AssetMetaAttribute(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 *AssetMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t assetId() SBE_NOEXCEPT { return 6937; } + static SBE_CONSTEXPR std::uint16_t assetId() SBE_NOEXCEPT + { + return 6937; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - assetSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t assetSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool assetInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool assetInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= assetSinceVersion(); + return m_actingVersion >= assetSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - assetEncodingOffset() SBE_NOEXCEPT { - return 29; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t assetEncodingOffset() SBE_NOEXCEPT + { + return 29; + } - static SBE_CONSTEXPR char assetNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char assetNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char assetMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char assetMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char assetMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char assetMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t assetEncodingLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::size_t assetEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t assetLength() SBE_NOEXCEPT { return 6; } + static SBE_CONSTEXPR std::uint64_t assetLength() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD const char *asset() const SBE_NOEXCEPT { - return m_buffer + m_offset + 29; - } + SBE_NODISCARD const char *asset() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 29; + } - SBE_NODISCARD char *asset() SBE_NOEXCEPT { return m_buffer + m_offset + 29; } + SBE_NODISCARD char *asset() SBE_NOEXCEPT + { + return m_buffer + m_offset + 29; + } - SBE_NODISCARD char asset(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for asset [E104]"); - } + SBE_NODISCARD char asset(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for asset [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 29 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 29 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture27 & - asset(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for asset [E105]"); - } + MDInstrumentDefinitionFuture27 &asset(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for asset [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 29 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 29 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getAsset(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error("length too large for getAsset [E106]"); - } + std::uint64_t getAsset(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getAsset [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 29, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 29, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionFuture27 & - putAsset(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 29, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionFuture27 &putAsset(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 29, src, sizeof(char) * 6); + return *this; + } - std::string getAssetAsString() const { - const char *buffer = m_buffer + m_offset + 29; - size_t length = 0; + SBE_NODISCARD std::string getAssetAsString() const + { + const char *buffer = m_buffer + m_offset + 29; + 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 getAssetAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getAssetAsString(); + std::string getAssetAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getAssetAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getAssetAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 29; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getAssetAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 29; + 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 - MDInstrumentDefinitionFuture27 &putAsset(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putAsset [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionFuture27 &putAsset(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putAsset [E106]"); + } - std::memcpy(m_buffer + m_offset + 29, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 29 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 29, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 29 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionFuture27 &putAsset(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putAsset [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionFuture27 &putAsset(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putAsset [E106]"); + } - std::memcpy(m_buffer + m_offset + 29, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 29 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 29, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 29 + start] = 0; + } - return *this; - } -#endif + 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 "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SymbolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t symbolId() SBE_NOEXCEPT { return 55; } + 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 static SBE_CONSTEXPR std::uint64_t symbolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool symbolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool symbolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= symbolSinceVersion(); + return m_actingVersion >= symbolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - symbolEncodingOffset() SBE_NOEXCEPT { - return 35; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t symbolEncodingOffset() SBE_NOEXCEPT + { + return 35; + } - static SBE_CONSTEXPR char symbolNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char symbolNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char symbolMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char symbolMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char symbolMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char symbolMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t symbolEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t symbolEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t symbolLength() 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 + 35; - } + SBE_NODISCARD const char *symbol() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 35; + } - SBE_NODISCARD char *symbol() SBE_NOEXCEPT { - return m_buffer + m_offset + 35; - } + SBE_NODISCARD char *symbol() SBE_NOEXCEPT + { + return m_buffer + m_offset + 35; + } - SBE_NODISCARD char symbol(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for symbol [E104]"); - } + 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 + 35 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 35 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture27 & - symbol(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for symbol [E105]"); - } + MDInstrumentDefinitionFuture27 &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 + 35 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 35 + (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::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 + 35, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 35, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionFuture27 & - putSymbol(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 35, src, sizeof(char) * 20); - return *this; - } + MDInstrumentDefinitionFuture27 &putSymbol(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 35, src, sizeof(char) * 20); + return *this; + } - std::string getSymbolAsString() const { - const char *buffer = m_buffer + m_offset + 35; - size_t length = 0; + SBE_NODISCARD std::string getSymbolAsString() const + { + const char *buffer = m_buffer + m_offset + 35; + 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 getSymbolAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSymbolAsString(); + std::string getSymbolAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSymbolAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSymbolAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 35; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSymbolAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 35; + 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 - MDInstrumentDefinitionFuture27 &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]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionFuture27 &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 + 35, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 35 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 35, str.data(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 35 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionFuture27 &putSymbol(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSymbol [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionFuture27 &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 + 35, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 35 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 35, str.c_str(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 35 + 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 55; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 55; + } - 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 + 55, 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 + 55, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionFuture27 & - securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 55, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 55, &val, sizeof(std::int32_t)); + return *this; + } - 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 ""; - } - } + 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; - } + 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 static SBE_CONSTEXPR std::uint64_t securityIDSourceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDSourceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDSourceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSourceSinceVersion(); + return m_actingVersion >= securityIDSourceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDSourceEncodingOffset() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDSourceEncodingOffset() SBE_NOEXCEPT + { + return 59; + } - static SBE_CONSTEXPR char securityIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityIDSourceNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityIDSourceMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityIDSourceMaxValue() SBE_NOEXCEPT { - return (char)126; - } + 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::size_t securityIDSourceEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t securityIDSourceLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t securityIDSourceLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *securityIDSource() const { - static const std::uint8_t securityIDSourceValues[] = {56}; + SBE_NODISCARD const char *securityIDSource() const + { + static const std::uint8_t securityIDSourceValues[] = { 56 }; - return (const char *)securityIDSourceValues; - } + return (const char *)securityIDSourceValues; + } - SBE_NODISCARD char securityIDSource(const std::uint64_t index) const { - static const std::uint8_t securityIDSourceValues[] = {56}; + SBE_NODISCARD char securityIDSource(const std::uint64_t index) const + { + static const std::uint8_t securityIDSourceValues[] = { 56 }; - return (char)securityIDSourceValues[index]; - } + 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::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::memcpy(dst, securityIDSourceValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getSecurityIDSourceAsString() const { - static const std::uint8_t SecurityIDSourceValues[] = {56}; + std::string getSecurityIDSourceAsString() const + { + static const std::uint8_t SecurityIDSourceValues[] = { 56 }; - return std::string((const char *)SecurityIDSourceValues, 1); - } + return std::string((const char *)SecurityIDSourceValues, 1); + } - std::string getSecurityIDSourceAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityIDSourceAsString(); + std::string getSecurityIDSourceAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityIDSourceAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 * - SecurityTypeMetaAttribute(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 *SecurityTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityTypeId() SBE_NOEXCEPT { - return 167; - } + 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 static SBE_CONSTEXPR std::uint64_t securityTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityTypeSinceVersion(); + return m_actingVersion >= securityTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityTypeEncodingOffset() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityTypeEncodingOffset() SBE_NOEXCEPT + { + return 59; + } - static SBE_CONSTEXPR char securityTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + 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::size_t securityTypeEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t securityTypeLength() 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 + 59; - } + SBE_NODISCARD const char *securityType() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 59; + } - SBE_NODISCARD char *securityType() SBE_NOEXCEPT { - return m_buffer + m_offset + 59; - } + SBE_NODISCARD char *securityType() SBE_NOEXCEPT + { + return m_buffer + m_offset + 59; + } - SBE_NODISCARD char securityType(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for securityType [E104]"); - } + 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 + 59 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 59 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture27 & - securityType(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for securityType [E105]"); - } + MDInstrumentDefinitionFuture27 &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 + 59 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 59 + (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::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 + 59, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 59, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionFuture27 & - putSecurityType(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 59, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionFuture27 &putSecurityType(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 59, src, sizeof(char) * 6); + return *this; + } - std::string getSecurityTypeAsString() const { - const char *buffer = m_buffer + m_offset + 59; - size_t length = 0; + SBE_NODISCARD std::string getSecurityTypeAsString() const + { + const char *buffer = m_buffer + m_offset + 59; + 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 getSecurityTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityTypeAsString(); + std::string getSecurityTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityTypeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityTypeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 59; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityTypeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 59; + 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 - MDInstrumentDefinitionFuture27 &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]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionFuture27 &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 + 59, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 59 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 59, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 59 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionFuture27 &putSecurityType(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityType [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionFuture27 &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 + 59, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 59 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 59, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 59 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - CFICodeMetaAttribute(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 *CFICodeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t cFICodeId() SBE_NOEXCEPT { return 461; } + static SBE_CONSTEXPR std::uint16_t cFICodeId() SBE_NOEXCEPT + { + return 461; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cFICodeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cFICodeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool cFICodeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool cFICodeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= cFICodeSinceVersion(); + return m_actingVersion >= cFICodeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cFICodeEncodingOffset() SBE_NOEXCEPT { - return 65; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cFICodeEncodingOffset() SBE_NOEXCEPT + { + return 65; + } - static SBE_CONSTEXPR char cFICodeNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char cFICodeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char cFICodeMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char cFICodeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char cFICodeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char cFICodeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t cFICodeEncodingLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::size_t cFICodeEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t cFICodeLength() SBE_NOEXCEPT { return 6; } + static SBE_CONSTEXPR std::uint64_t cFICodeLength() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD const char *cFICode() const SBE_NOEXCEPT { - return m_buffer + m_offset + 65; - } + SBE_NODISCARD const char *cFICode() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 65; + } - SBE_NODISCARD char *cFICode() SBE_NOEXCEPT { - return m_buffer + m_offset + 65; - } + SBE_NODISCARD char *cFICode() SBE_NOEXCEPT + { + return m_buffer + m_offset + 65; + } - SBE_NODISCARD char cFICode(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for cFICode [E104]"); - } + SBE_NODISCARD char cFICode(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for cFICode [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); + } - MDInstrumentDefinitionFuture27 & - cFICode(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for cFICode [E105]"); - } + MDInstrumentDefinitionFuture27 &cFICode(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for cFICode [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 getCFICode(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error("length too large for getCFICode [E106]"); - } + std::uint64_t getCFICode(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getCFICode [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; + } - MDInstrumentDefinitionFuture27 & - putCFICode(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 65, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionFuture27 &putCFICode(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 65, src, sizeof(char) * 6); + return *this; + } - std::string getCFICodeAsString() const { - const char *buffer = m_buffer + m_offset + 65; - size_t length = 0; + SBE_NODISCARD std::string getCFICodeAsString() const + { + const char *buffer = m_buffer + m_offset + 65; + 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 getCFICodeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCFICodeAsString(); + std::string getCFICodeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCFICodeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getCFICodeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 65; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCFICodeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 65; + 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 - MDInstrumentDefinitionFuture27 &putCFICode(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putCFICode [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionFuture27 &putCFICode(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putCFICode [E106]"); + } - std::memcpy(m_buffer + m_offset + 65, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 65 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 65, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 65 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionFuture27 &putCFICode(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putCFICode [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionFuture27 &putCFICode(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putCFICode [E106]"); + } - std::memcpy(m_buffer + m_offset + 65, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 65 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 65, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 65 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - 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 ""; - } - } + 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; - } + 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 static SBE_CONSTEXPR std::uint64_t maturityMonthYearSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool maturityMonthYearInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool maturityMonthYearInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= maturityMonthYearSinceVersion(); + return m_actingVersion >= maturityMonthYearSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maturityMonthYearEncodingOffset() SBE_NOEXCEPT { - return 71; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maturityMonthYearEncodingOffset() SBE_NOEXCEPT + { + return 71; + } - private: - MaturityMonthYear m_maturityMonthYear; +private: + MaturityMonthYear m_maturityMonthYear; - public: - SBE_NODISCARD MaturityMonthYear &maturityMonthYear() { - m_maturityMonthYear.wrap( - m_buffer, m_offset + 71, m_actingVersion, m_bufferLength); - return m_maturityMonthYear; - } +public: + SBE_NODISCARD MaturityMonthYear &maturityMonthYear() + { + m_maturityMonthYear.wrap(m_buffer, m_offset + 71, m_actingVersion, m_bufferLength); + return m_maturityMonthYear; + } - SBE_NODISCARD static const char * - CurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Currency"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Currency"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t currencyId() SBE_NOEXCEPT { return 15; } + 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 static SBE_CONSTEXPR std::uint64_t currencySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool currencyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool currencyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= currencySinceVersion(); + return m_actingVersion >= currencySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - currencyEncodingOffset() SBE_NOEXCEPT { - return 76; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t currencyEncodingOffset() SBE_NOEXCEPT + { + return 76; + } - static SBE_CONSTEXPR char currencyNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char currencyNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char currencyMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char currencyMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char currencyMaxValue() SBE_NOEXCEPT { - return (char)126; - } + 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::size_t currencyEncodingLength() SBE_NOEXCEPT + { + return 3; + } - static SBE_CONSTEXPR std::uint64_t currencyLength() 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 + 76; - } + SBE_NODISCARD const char *currency() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 76; + } - SBE_NODISCARD char *currency() SBE_NOEXCEPT { - return m_buffer + m_offset + 76; - } + SBE_NODISCARD char *currency() SBE_NOEXCEPT + { + return m_buffer + m_offset + 76; + } - SBE_NODISCARD char currency(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error("index out of range for currency [E104]"); - } + 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 + 76 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 76 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture27 & - currency(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error("index out of range for currency [E105]"); - } + MDInstrumentDefinitionFuture27 ¤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 + 76 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 76 + (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::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 + 76, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 76, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionFuture27 & - putCurrency(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 76, src, sizeof(char) * 3); - return *this; - } + MDInstrumentDefinitionFuture27 &putCurrency(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 76, src, sizeof(char) * 3); + return *this; + } - MDInstrumentDefinitionFuture27 &putCurrency( - const char value0, const char value1, const char value2) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 76, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 77, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 78, &val2, sizeof(char)); + MDInstrumentDefinitionFuture27 &putCurrency( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 76, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 77, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 78, &val2, sizeof(char)); - return *this; - } + return *this; + } - std::string getCurrencyAsString() const { - const char *buffer = m_buffer + m_offset + 76; - size_t length = 0; + SBE_NODISCARD std::string getCurrencyAsString() const + { + const char *buffer = m_buffer + m_offset + 76; + 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 getCurrencyAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCurrencyAsString(); + std::string getCurrencyAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCurrencyAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getCurrencyAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 76; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCurrencyAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 76; + 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 - MDInstrumentDefinitionFuture27 &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]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionFuture27 &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 + 76, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 76 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 76, str.data(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 76 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionFuture27 &putCurrency(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error("string too large for putCurrency [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionFuture27 &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 + 76, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 76 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 76, str.c_str(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 76 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SettlCurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Currency"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SettlCurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Currency"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t settlCurrencyId() SBE_NOEXCEPT { - return 120; - } + static SBE_CONSTEXPR std::uint16_t settlCurrencyId() SBE_NOEXCEPT + { + return 120; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - settlCurrencySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t settlCurrencySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool settlCurrencyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool settlCurrencyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= settlCurrencySinceVersion(); + return m_actingVersion >= settlCurrencySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - settlCurrencyEncodingOffset() SBE_NOEXCEPT { - return 79; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t settlCurrencyEncodingOffset() SBE_NOEXCEPT + { + return 79; + } - static SBE_CONSTEXPR char settlCurrencyNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char settlCurrencyNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char settlCurrencyMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char settlCurrencyMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char settlCurrencyMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char settlCurrencyMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t settlCurrencyEncodingLength() SBE_NOEXCEPT { - return 3; - } + static SBE_CONSTEXPR std::size_t settlCurrencyEncodingLength() SBE_NOEXCEPT + { + return 3; + } - static SBE_CONSTEXPR std::uint64_t settlCurrencyLength() SBE_NOEXCEPT { - return 3; - } + static SBE_CONSTEXPR std::uint64_t settlCurrencyLength() SBE_NOEXCEPT + { + return 3; + } - SBE_NODISCARD const char *settlCurrency() const SBE_NOEXCEPT { - return m_buffer + m_offset + 79; - } + SBE_NODISCARD const char *settlCurrency() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 79; + } - SBE_NODISCARD char *settlCurrency() SBE_NOEXCEPT { - return m_buffer + m_offset + 79; - } + SBE_NODISCARD char *settlCurrency() SBE_NOEXCEPT + { + return m_buffer + m_offset + 79; + } - SBE_NODISCARD char settlCurrency(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error( - "index out of range for settlCurrency [E104]"); - } + SBE_NODISCARD char settlCurrency(const std::uint64_t index) const + { + if (index >= 3) + { + throw std::runtime_error("index out of range for settlCurrency [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 79 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 79 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture27 & - settlCurrency(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error( - "index out of range for settlCurrency [E105]"); - } + MDInstrumentDefinitionFuture27 &settlCurrency(const std::uint64_t index, const char value) + { + if (index >= 3) + { + throw std::runtime_error("index out of range for settlCurrency [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 79 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 79 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSettlCurrency(char *const dst, const std::uint64_t length) const { - if (length > 3) { - throw std::runtime_error( - "length too large for getSettlCurrency [E106]"); - } + std::uint64_t getSettlCurrency(char *const dst, const std::uint64_t length) const + { + if (length > 3) + { + throw std::runtime_error("length too large for getSettlCurrency [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 79, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 79, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionFuture27 & - putSettlCurrency(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 79, src, sizeof(char) * 3); - return *this; - } + MDInstrumentDefinitionFuture27 &putSettlCurrency(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 79, src, sizeof(char) * 3); + return *this; + } - MDInstrumentDefinitionFuture27 &putSettlCurrency( - const char value0, const char value1, const char value2) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 79, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 80, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 81, &val2, sizeof(char)); + MDInstrumentDefinitionFuture27 &putSettlCurrency( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 79, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 80, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 81, &val2, sizeof(char)); - return *this; - } + return *this; + } - std::string getSettlCurrencyAsString() const { - const char *buffer = m_buffer + m_offset + 79; - size_t length = 0; + SBE_NODISCARD std::string getSettlCurrencyAsString() const + { + const char *buffer = m_buffer + m_offset + 79; + 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 getSettlCurrencyAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSettlCurrencyAsString(); + std::string getSettlCurrencyAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSettlCurrencyAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSettlCurrencyAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 79; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSettlCurrencyAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 79; + 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 - MDInstrumentDefinitionFuture27 & - putSettlCurrency(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putSettlCurrency [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionFuture27 &putSettlCurrency(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putSettlCurrency [E106]"); + } - std::memcpy(m_buffer + m_offset + 79, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 79 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 79, str.data(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 79 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionFuture27 &putSettlCurrency(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putSettlCurrency [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionFuture27 &putSettlCurrency(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putSettlCurrency [E106]"); + } - std::memcpy(m_buffer + m_offset + 79, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 79 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 79, str.c_str(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 79 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - MatchAlgorithmMetaAttribute(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 *MatchAlgorithmMetaAttribute(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 matchAlgorithmId() SBE_NOEXCEPT { - return 1142; - } + static SBE_CONSTEXPR std::uint16_t matchAlgorithmId() SBE_NOEXCEPT + { + return 1142; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchAlgorithmSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchAlgorithmSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchAlgorithmInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchAlgorithmInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchAlgorithmSinceVersion(); + return m_actingVersion >= matchAlgorithmSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchAlgorithmEncodingOffset() SBE_NOEXCEPT { - return 82; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchAlgorithmEncodingOffset() SBE_NOEXCEPT + { + return 82; + } - static SBE_CONSTEXPR char matchAlgorithmNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char matchAlgorithmNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char matchAlgorithmMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char matchAlgorithmMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char matchAlgorithmMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char matchAlgorithmMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - matchAlgorithmEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchAlgorithmEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD char matchAlgorithm() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 82, sizeof(char)); - return (val); - } + SBE_NODISCARD char matchAlgorithm() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 82, sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture27 & - matchAlgorithm(const char value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 82, &val, sizeof(char)); - return *this; - } + MDInstrumentDefinitionFuture27 &matchAlgorithm(const char value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 82, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char * - MinTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MinTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t minTradeVolId() SBE_NOEXCEPT { - return 562; - } + static SBE_CONSTEXPR std::uint16_t minTradeVolId() SBE_NOEXCEPT + { + return 562; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minTradeVolSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minTradeVolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minTradeVolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minTradeVolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minTradeVolSinceVersion(); + return m_actingVersion >= minTradeVolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minTradeVolEncodingOffset() SBE_NOEXCEPT { - return 83; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minTradeVolEncodingOffset() SBE_NOEXCEPT + { + return 83; + } - static SBE_CONSTEXPR std::uint32_t minTradeVolNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t minTradeVolNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t minTradeVolMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t minTradeVolMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t minTradeVolMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t minTradeVolMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t minTradeVolEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t minTradeVolEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t minTradeVol() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 83, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t minTradeVol() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 83, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionFuture27 & - minTradeVol(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 83, &val, sizeof(std::uint32_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &minTradeVol(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 83, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - MaxTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MaxTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t maxTradeVolId() SBE_NOEXCEPT { - return 1140; - } + static SBE_CONSTEXPR std::uint16_t maxTradeVolId() SBE_NOEXCEPT + { + return 1140; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - maxTradeVolSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maxTradeVolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool maxTradeVolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool maxTradeVolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= maxTradeVolSinceVersion(); + return m_actingVersion >= maxTradeVolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maxTradeVolEncodingOffset() SBE_NOEXCEPT { - return 87; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maxTradeVolEncodingOffset() SBE_NOEXCEPT + { + return 87; + } - static SBE_CONSTEXPR std::uint32_t maxTradeVolNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t maxTradeVolNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t maxTradeVolMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t maxTradeVolMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t maxTradeVolMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t maxTradeVolMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t maxTradeVolEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t maxTradeVolEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t maxTradeVol() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 87, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t maxTradeVol() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 87, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionFuture27 & - maxTradeVol(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 87, &val, sizeof(std::uint32_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &maxTradeVol(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 87, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char *MinPriceIncrementMetaAttribute( - 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 *MinPriceIncrementMetaAttribute(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 minPriceIncrementId() SBE_NOEXCEPT { - return 969; - } + static SBE_CONSTEXPR std::uint16_t minPriceIncrementId() SBE_NOEXCEPT + { + return 969; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minPriceIncrementSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minPriceIncrementSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minPriceIncrementInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minPriceIncrementInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minPriceIncrementSinceVersion(); + return m_actingVersion >= minPriceIncrementSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minPriceIncrementEncodingOffset() SBE_NOEXCEPT { - return 91; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minPriceIncrementEncodingOffset() SBE_NOEXCEPT + { + return 91; + } - private: - PRICE m_minPriceIncrement; +private: + PRICE m_minPriceIncrement; - public: - SBE_NODISCARD PRICE &minPriceIncrement() { - m_minPriceIncrement.wrap( - m_buffer, m_offset + 91, m_actingVersion, m_bufferLength); - return m_minPriceIncrement; - } +public: + SBE_NODISCARD PRICE &minPriceIncrement() + { + m_minPriceIncrement.wrap(m_buffer, m_offset + 91, m_actingVersion, m_bufferLength); + return m_minPriceIncrement; + } - SBE_NODISCARD static const char * - DisplayFactorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "float"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DisplayFactorMetaAttribute(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 displayFactorId() SBE_NOEXCEPT { - return 9787; - } + static SBE_CONSTEXPR std::uint16_t displayFactorId() SBE_NOEXCEPT + { + return 9787; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - displayFactorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t displayFactorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool displayFactorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool displayFactorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= displayFactorSinceVersion(); + return m_actingVersion >= displayFactorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - displayFactorEncodingOffset() SBE_NOEXCEPT { - return 99; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t displayFactorEncodingOffset() SBE_NOEXCEPT + { + return 99; + } - private: - FLOAT m_displayFactor; +private: + FLOAT m_displayFactor; - public: - SBE_NODISCARD FLOAT &displayFactor() { - m_displayFactor.wrap( - m_buffer, m_offset + 99, m_actingVersion, m_bufferLength); - return m_displayFactor; - } +public: + SBE_NODISCARD FLOAT &displayFactor() + { + m_displayFactor.wrap(m_buffer, m_offset + 99, m_actingVersion, m_bufferLength); + return m_displayFactor; + } - SBE_NODISCARD static const char * - MainFractionMetaAttribute(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 *MainFractionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mainFractionId() SBE_NOEXCEPT { - return 37702; - } + static SBE_CONSTEXPR std::uint16_t mainFractionId() SBE_NOEXCEPT + { + return 37702; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mainFractionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mainFractionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mainFractionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mainFractionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mainFractionSinceVersion(); + return m_actingVersion >= mainFractionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mainFractionEncodingOffset() SBE_NOEXCEPT { - return 107; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mainFractionEncodingOffset() SBE_NOEXCEPT + { + return 107; + } - static SBE_CONSTEXPR std::uint8_t mainFractionNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t mainFractionNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t mainFractionMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t mainFractionMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t mainFractionMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t mainFractionMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t mainFractionEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t mainFractionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t mainFraction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 107, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t mainFraction() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 107, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionFuture27 & - mainFraction(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 107, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &mainFraction(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 107, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - SubFractionMetaAttribute(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 *SubFractionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t subFractionId() SBE_NOEXCEPT { - return 37703; - } + static SBE_CONSTEXPR std::uint16_t subFractionId() SBE_NOEXCEPT + { + return 37703; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - subFractionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t subFractionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool subFractionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool subFractionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= subFractionSinceVersion(); + return m_actingVersion >= subFractionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - subFractionEncodingOffset() SBE_NOEXCEPT { - return 108; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t subFractionEncodingOffset() SBE_NOEXCEPT + { + return 108; + } - static SBE_CONSTEXPR std::uint8_t subFractionNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t subFractionNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t subFractionMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t subFractionMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t subFractionMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t subFractionMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t subFractionEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t subFractionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t subFraction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 108, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t subFraction() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 108, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionFuture27 & - subFraction(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 108, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &subFraction(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 108, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char *PriceDisplayFormatMetaAttribute( - 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 *PriceDisplayFormatMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t priceDisplayFormatId() SBE_NOEXCEPT { - return 9800; - } + static SBE_CONSTEXPR std::uint16_t priceDisplayFormatId() SBE_NOEXCEPT + { + return 9800; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceDisplayFormatSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceDisplayFormatSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool priceDisplayFormatInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool priceDisplayFormatInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= priceDisplayFormatSinceVersion(); + return m_actingVersion >= priceDisplayFormatSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceDisplayFormatEncodingOffset() SBE_NOEXCEPT { - return 109; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceDisplayFormatEncodingOffset() SBE_NOEXCEPT + { + return 109; + } - static SBE_CONSTEXPR std::uint8_t - priceDisplayFormatNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t priceDisplayFormatNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - priceDisplayFormatEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t priceDisplayFormatEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t priceDisplayFormat() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 109, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t priceDisplayFormat() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 109, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionFuture27 & - priceDisplayFormat(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 109, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &priceDisplayFormat(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 109, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - UnitOfMeasureMetaAttribute(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 *UnitOfMeasureMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t unitOfMeasureId() SBE_NOEXCEPT { - return 996; - } + static SBE_CONSTEXPR std::uint16_t unitOfMeasureId() SBE_NOEXCEPT + { + return 996; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - unitOfMeasureSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t unitOfMeasureSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool unitOfMeasureInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool unitOfMeasureInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= unitOfMeasureSinceVersion(); + return m_actingVersion >= unitOfMeasureSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - unitOfMeasureEncodingOffset() SBE_NOEXCEPT { - return 110; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t unitOfMeasureEncodingOffset() SBE_NOEXCEPT + { + return 110; + } - static SBE_CONSTEXPR char unitOfMeasureNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char unitOfMeasureNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char unitOfMeasureMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char unitOfMeasureMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char unitOfMeasureMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char unitOfMeasureMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t unitOfMeasureEncodingLength() SBE_NOEXCEPT { - return 30; - } + static SBE_CONSTEXPR std::size_t unitOfMeasureEncodingLength() SBE_NOEXCEPT + { + return 30; + } - static SBE_CONSTEXPR std::uint64_t unitOfMeasureLength() SBE_NOEXCEPT { - return 30; - } + static SBE_CONSTEXPR std::uint64_t unitOfMeasureLength() SBE_NOEXCEPT + { + return 30; + } - SBE_NODISCARD const char *unitOfMeasure() const SBE_NOEXCEPT { - return m_buffer + m_offset + 110; - } + SBE_NODISCARD const char *unitOfMeasure() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 110; + } - SBE_NODISCARD char *unitOfMeasure() SBE_NOEXCEPT { - return m_buffer + m_offset + 110; - } + SBE_NODISCARD char *unitOfMeasure() SBE_NOEXCEPT + { + return m_buffer + m_offset + 110; + } - SBE_NODISCARD char unitOfMeasure(const std::uint64_t index) const { - if (index >= 30) { - throw std::runtime_error( - "index out of range for unitOfMeasure [E104]"); - } + SBE_NODISCARD char unitOfMeasure(const std::uint64_t index) const + { + if (index >= 30) + { + throw std::runtime_error("index out of range for unitOfMeasure [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 110 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 110 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture27 & - unitOfMeasure(const std::uint64_t index, const char value) { - if (index >= 30) { - throw std::runtime_error( - "index out of range for unitOfMeasure [E105]"); - } + MDInstrumentDefinitionFuture27 &unitOfMeasure(const std::uint64_t index, const char value) + { + if (index >= 30) + { + throw std::runtime_error("index out of range for unitOfMeasure [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 110 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 110 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getUnitOfMeasure(char *const dst, const std::uint64_t length) const { - if (length > 30) { - throw std::runtime_error( - "length too large for getUnitOfMeasure [E106]"); - } + std::uint64_t getUnitOfMeasure(char *const dst, const std::uint64_t length) const + { + if (length > 30) + { + throw std::runtime_error("length too large for getUnitOfMeasure [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 110, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 110, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionFuture27 & - putUnitOfMeasure(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 110, src, sizeof(char) * 30); - return *this; - } + MDInstrumentDefinitionFuture27 &putUnitOfMeasure(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 110, src, sizeof(char) * 30); + return *this; + } - std::string getUnitOfMeasureAsString() const { - const char *buffer = m_buffer + m_offset + 110; - size_t length = 0; + SBE_NODISCARD std::string getUnitOfMeasureAsString() const + { + const char *buffer = m_buffer + m_offset + 110; + 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 getUnitOfMeasureAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getUnitOfMeasureAsString(); + std::string getUnitOfMeasureAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getUnitOfMeasureAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getUnitOfMeasureAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 110; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getUnitOfMeasureAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 110; + 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 - MDInstrumentDefinitionFuture27 & - putUnitOfMeasure(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 30) { - throw std::runtime_error( - "string too large for putUnitOfMeasure [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionFuture27 &putUnitOfMeasure(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 30) + { + throw std::runtime_error("string too large for putUnitOfMeasure [E106]"); + } - std::memcpy(m_buffer + m_offset + 110, str.data(), srcLength); - for (size_t start = srcLength; start < 30; ++start) { - m_buffer[m_offset + 110 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 110, str.data(), srcLength); + for (size_t start = srcLength; start < 30; ++start) + { + m_buffer[m_offset + 110 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionFuture27 &putUnitOfMeasure(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 30) { - throw std::runtime_error( - "string too large for putUnitOfMeasure [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionFuture27 &putUnitOfMeasure(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 30) + { + throw std::runtime_error("string too large for putUnitOfMeasure [E106]"); + } - std::memcpy(m_buffer + m_offset + 110, str.c_str(), srcLength); - for (size_t start = srcLength; start < 30; ++start) { - m_buffer[m_offset + 110 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 110, str.c_str(), srcLength); + for (size_t start = srcLength; start < 30; ++start) + { + m_buffer[m_offset + 110 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *UnitOfMeasureQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UnitOfMeasureQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t unitOfMeasureQtyId() SBE_NOEXCEPT { - return 1147; - } + static SBE_CONSTEXPR std::uint16_t unitOfMeasureQtyId() SBE_NOEXCEPT + { + return 1147; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - unitOfMeasureQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t unitOfMeasureQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool unitOfMeasureQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool unitOfMeasureQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= unitOfMeasureQtySinceVersion(); + return m_actingVersion >= unitOfMeasureQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - unitOfMeasureQtyEncodingOffset() SBE_NOEXCEPT { - return 140; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t unitOfMeasureQtyEncodingOffset() SBE_NOEXCEPT + { + return 140; + } - private: - PRICENULL m_unitOfMeasureQty; +private: + PRICENULL m_unitOfMeasureQty; - public: - SBE_NODISCARD PRICENULL &unitOfMeasureQty() { - m_unitOfMeasureQty.wrap( - m_buffer, m_offset + 140, m_actingVersion, m_bufferLength); - return m_unitOfMeasureQty; - } +public: + SBE_NODISCARD PRICENULL &unitOfMeasureQty() + { + m_unitOfMeasureQty.wrap(m_buffer, m_offset + 140, m_actingVersion, m_bufferLength); + return m_unitOfMeasureQty; + } - SBE_NODISCARD static const char *TradingReferencePriceMetaAttribute( - 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 *TradingReferencePriceMetaAttribute(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 tradingReferencePriceId() SBE_NOEXCEPT { - return 1150; - } + static SBE_CONSTEXPR std::uint16_t tradingReferencePriceId() SBE_NOEXCEPT + { + return 1150; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingReferencePriceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingReferencePriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool tradingReferencePriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tradingReferencePriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tradingReferencePriceSinceVersion(); + return m_actingVersion >= tradingReferencePriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingReferencePriceEncodingOffset() SBE_NOEXCEPT { - return 148; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingReferencePriceEncodingOffset() SBE_NOEXCEPT + { + return 148; + } - private: - PRICENULL m_tradingReferencePrice; +private: + PRICENULL m_tradingReferencePrice; - public: - SBE_NODISCARD PRICENULL &tradingReferencePrice() { - m_tradingReferencePrice.wrap( - m_buffer, m_offset + 148, m_actingVersion, m_bufferLength); - return m_tradingReferencePrice; - } +public: + SBE_NODISCARD PRICENULL &tradingReferencePrice() + { + m_tradingReferencePrice.wrap(m_buffer, m_offset + 148, m_actingVersion, m_bufferLength); + return m_tradingReferencePrice; + } - SBE_NODISCARD static const char * - SettlPriceTypeMetaAttribute(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 *SettlPriceTypeMetaAttribute(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 settlPriceTypeId() SBE_NOEXCEPT { - return 731; - } + static SBE_CONSTEXPR std::uint16_t settlPriceTypeId() SBE_NOEXCEPT + { + return 731; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - settlPriceTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t settlPriceTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= settlPriceTypeSinceVersion(); + return m_actingVersion >= settlPriceTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingOffset() SBE_NOEXCEPT { - return 156; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingOffset() SBE_NOEXCEPT + { + return 156; + } - private: - SettlPriceType m_settlPriceType; +private: + SettlPriceType m_settlPriceType; - public: - SBE_NODISCARD SettlPriceType &settlPriceType() { - m_settlPriceType.wrap( - m_buffer, m_offset + 156, m_actingVersion, m_bufferLength); - return m_settlPriceType; - } +public: + SBE_NODISCARD SettlPriceType &settlPriceType() + { + m_settlPriceType.wrap(m_buffer, m_offset + 156, m_actingVersion, m_bufferLength); + return m_settlPriceType; + } - static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char *OpenInterestQtyMetaAttribute( - 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 *OpenInterestQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t openInterestQtyId() SBE_NOEXCEPT { - return 5792; - } + static SBE_CONSTEXPR std::uint16_t openInterestQtyId() SBE_NOEXCEPT + { + return 5792; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - openInterestQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t openInterestQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool openInterestQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool openInterestQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= openInterestQtySinceVersion(); + return m_actingVersion >= openInterestQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - openInterestQtyEncodingOffset() SBE_NOEXCEPT { - return 157; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t openInterestQtyEncodingOffset() SBE_NOEXCEPT + { + return 157; + } - static SBE_CONSTEXPR std::int32_t openInterestQtyNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t openInterestQtyNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t openInterestQtyMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t openInterestQtyMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t openInterestQtyMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t openInterestQtyMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t - openInterestQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t openInterestQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t openInterestQty() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 157, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t openInterestQty() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 157, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionFuture27 & - openInterestQty(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 157, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &openInterestQty(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 157, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - ClearedVolumeMetaAttribute(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 *ClearedVolumeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t clearedVolumeId() SBE_NOEXCEPT { - return 5791; - } + static SBE_CONSTEXPR std::uint16_t clearedVolumeId() SBE_NOEXCEPT + { + return 5791; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clearedVolumeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clearedVolumeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool clearedVolumeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool clearedVolumeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clearedVolumeSinceVersion(); + return m_actingVersion >= clearedVolumeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clearedVolumeEncodingOffset() SBE_NOEXCEPT { - return 161; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clearedVolumeEncodingOffset() SBE_NOEXCEPT + { + return 161; + } - static SBE_CONSTEXPR std::int32_t clearedVolumeNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t clearedVolumeNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t clearedVolumeMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t clearedVolumeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t clearedVolumeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t clearedVolumeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t clearedVolumeEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t clearedVolumeEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t clearedVolume() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 161, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t clearedVolume() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 161, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionFuture27 & - clearedVolume(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 161, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &clearedVolume(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 161, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - HighLimitPriceMetaAttribute(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 *HighLimitPriceMetaAttribute(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 highLimitPriceId() SBE_NOEXCEPT { - return 1149; - } + static SBE_CONSTEXPR std::uint16_t highLimitPriceId() SBE_NOEXCEPT + { + return 1149; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - highLimitPriceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t highLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= highLimitPriceSinceVersion(); + return m_actingVersion >= highLimitPriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - highLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 165; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t highLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 165; + } - private: - PRICENULL m_highLimitPrice; +private: + PRICENULL m_highLimitPrice; - public: - SBE_NODISCARD PRICENULL &highLimitPrice() { - m_highLimitPrice.wrap( - m_buffer, m_offset + 165, m_actingVersion, m_bufferLength); - return m_highLimitPrice; - } +public: + SBE_NODISCARD PRICENULL &highLimitPrice() + { + m_highLimitPrice.wrap(m_buffer, m_offset + 165, m_actingVersion, m_bufferLength); + return m_highLimitPrice; + } - SBE_NODISCARD static const char * - LowLimitPriceMetaAttribute(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 *LowLimitPriceMetaAttribute(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 lowLimitPriceId() SBE_NOEXCEPT { - return 1148; - } + static SBE_CONSTEXPR std::uint16_t lowLimitPriceId() SBE_NOEXCEPT + { + return 1148; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lowLimitPriceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lowLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lowLimitPriceSinceVersion(); + return m_actingVersion >= lowLimitPriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lowLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 173; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lowLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 173; + } - private: - PRICENULL m_lowLimitPrice; +private: + PRICENULL m_lowLimitPrice; - public: - SBE_NODISCARD PRICENULL &lowLimitPrice() { - m_lowLimitPrice.wrap( - m_buffer, m_offset + 173, m_actingVersion, m_bufferLength); - return m_lowLimitPrice; - } +public: + SBE_NODISCARD PRICENULL &lowLimitPrice() + { + m_lowLimitPrice.wrap(m_buffer, m_offset + 173, m_actingVersion, m_bufferLength); + return m_lowLimitPrice; + } - SBE_NODISCARD static const char *MaxPriceVariationMetaAttribute( - 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 *MaxPriceVariationMetaAttribute(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 maxPriceVariationId() SBE_NOEXCEPT { - return 1143; - } + static SBE_CONSTEXPR std::uint16_t maxPriceVariationId() SBE_NOEXCEPT + { + return 1143; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - maxPriceVariationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maxPriceVariationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool maxPriceVariationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool maxPriceVariationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= maxPriceVariationSinceVersion(); + return m_actingVersion >= maxPriceVariationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maxPriceVariationEncodingOffset() SBE_NOEXCEPT { - return 181; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maxPriceVariationEncodingOffset() SBE_NOEXCEPT + { + return 181; + } - private: - PRICENULL m_maxPriceVariation; +private: + PRICENULL m_maxPriceVariation; - public: - SBE_NODISCARD PRICENULL &maxPriceVariation() { - m_maxPriceVariation.wrap( - m_buffer, m_offset + 181, m_actingVersion, m_bufferLength); - return m_maxPriceVariation; - } +public: + SBE_NODISCARD PRICENULL &maxPriceVariation() + { + m_maxPriceVariation.wrap(m_buffer, m_offset + 181, m_actingVersion, m_bufferLength); + return m_maxPriceVariation; + } - SBE_NODISCARD static const char * - DecayQuantityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DecayQuantityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t decayQuantityId() SBE_NOEXCEPT { - return 5818; - } + static SBE_CONSTEXPR std::uint16_t decayQuantityId() SBE_NOEXCEPT + { + return 5818; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - decayQuantitySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t decayQuantitySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool decayQuantityInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool decayQuantityInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= decayQuantitySinceVersion(); + return m_actingVersion >= decayQuantitySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - decayQuantityEncodingOffset() SBE_NOEXCEPT { - return 189; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t decayQuantityEncodingOffset() SBE_NOEXCEPT + { + return 189; + } - static SBE_CONSTEXPR std::int32_t decayQuantityNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t decayQuantityNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t decayQuantityMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t decayQuantityMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t decayQuantityMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t decayQuantityMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t decayQuantityEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t decayQuantityEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t decayQuantity() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 189, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t decayQuantity() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 189, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionFuture27 & - decayQuantity(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 189, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &decayQuantity(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 189, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - DecayStartDateMetaAttribute(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 *DecayStartDateMetaAttribute(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 decayStartDateId() SBE_NOEXCEPT { - return 5819; - } + static SBE_CONSTEXPR std::uint16_t decayStartDateId() SBE_NOEXCEPT + { + return 5819; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - decayStartDateSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t decayStartDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool decayStartDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool decayStartDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= decayStartDateSinceVersion(); + return m_actingVersion >= decayStartDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - decayStartDateEncodingOffset() SBE_NOEXCEPT { - return 193; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t decayStartDateEncodingOffset() SBE_NOEXCEPT + { + return 193; + } - static SBE_CONSTEXPR std::uint16_t decayStartDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t decayStartDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t decayStartDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t decayStartDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t decayStartDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t decayStartDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t - decayStartDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t decayStartDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t decayStartDate() 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 decayStartDate() 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); + } - MDInstrumentDefinitionFuture27 & - decayStartDate(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; - } + MDInstrumentDefinitionFuture27 &decayStartDate(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 *OriginalContractSizeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OriginalContractSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t originalContractSizeId() SBE_NOEXCEPT { - return 5849; - } + static SBE_CONSTEXPR std::uint16_t originalContractSizeId() SBE_NOEXCEPT + { + return 5849; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - originalContractSizeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t originalContractSizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool originalContractSizeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool originalContractSizeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= originalContractSizeSinceVersion(); + return m_actingVersion >= originalContractSizeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - originalContractSizeEncodingOffset() SBE_NOEXCEPT { - return 195; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t originalContractSizeEncodingOffset() SBE_NOEXCEPT + { + return 195; + } - static SBE_CONSTEXPR std::int32_t - originalContractSizeNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t originalContractSizeNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t - originalContractSizeMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t originalContractSizeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t - originalContractSizeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t originalContractSizeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t - originalContractSizeEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t originalContractSizeEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t originalContractSize() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 195, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t originalContractSize() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 195, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionFuture27 & - originalContractSize(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 195, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &originalContractSize(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 195, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char *ContractMultiplierMetaAttribute( - 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 *ContractMultiplierMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t contractMultiplierId() SBE_NOEXCEPT { - return 231; - } + static SBE_CONSTEXPR std::uint16_t contractMultiplierId() SBE_NOEXCEPT + { + return 231; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - contractMultiplierSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t contractMultiplierSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool contractMultiplierInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool contractMultiplierInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= contractMultiplierSinceVersion(); + return m_actingVersion >= contractMultiplierSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - contractMultiplierEncodingOffset() SBE_NOEXCEPT { - return 199; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t contractMultiplierEncodingOffset() SBE_NOEXCEPT + { + return 199; + } - static SBE_CONSTEXPR std::int32_t - contractMultiplierNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t contractMultiplierNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t contractMultiplierMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t contractMultiplierMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t contractMultiplierMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t contractMultiplierMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t - contractMultiplierEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t contractMultiplierEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t contractMultiplier() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 199, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t contractMultiplier() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 199, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionFuture27 & - contractMultiplier(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 199, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &contractMultiplier(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 199, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char *ContractMultiplierUnitMetaAttribute( - 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 *ContractMultiplierUnitMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t contractMultiplierUnitId() SBE_NOEXCEPT { - return 1435; - } + static SBE_CONSTEXPR std::uint16_t contractMultiplierUnitId() SBE_NOEXCEPT + { + return 1435; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - contractMultiplierUnitSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t contractMultiplierUnitSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool contractMultiplierUnitInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool contractMultiplierUnitInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= contractMultiplierUnitSinceVersion(); + return m_actingVersion >= contractMultiplierUnitSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - contractMultiplierUnitEncodingOffset() SBE_NOEXCEPT { - return 203; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t contractMultiplierUnitEncodingOffset() SBE_NOEXCEPT + { + return 203; + } - static SBE_CONSTEXPR std::int8_t - contractMultiplierUnitNullValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t contractMultiplierUnitNullValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::int8_t - contractMultiplierUnitMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } + static SBE_CONSTEXPR std::int8_t contractMultiplierUnitMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } - static SBE_CONSTEXPR std::int8_t - contractMultiplierUnitMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t contractMultiplierUnitMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::size_t - contractMultiplierUnitEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t contractMultiplierUnitEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::int8_t contractMultiplierUnit() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 203, sizeof(std::int8_t)); - return (val); - } + SBE_NODISCARD std::int8_t contractMultiplierUnit() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 203, sizeof(std::int8_t)); + return (val); + } - MDInstrumentDefinitionFuture27 & - contractMultiplierUnit(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 203, &val, sizeof(std::int8_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &contractMultiplierUnit(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 203, &val, sizeof(std::int8_t)); + return *this; + } - SBE_NODISCARD static const char *FlowScheduleTypeMetaAttribute( - 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 *FlowScheduleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t flowScheduleTypeId() SBE_NOEXCEPT { - return 1439; - } + static SBE_CONSTEXPR std::uint16_t flowScheduleTypeId() SBE_NOEXCEPT + { + return 1439; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - flowScheduleTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t flowScheduleTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool flowScheduleTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool flowScheduleTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= flowScheduleTypeSinceVersion(); + return m_actingVersion >= flowScheduleTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - flowScheduleTypeEncodingOffset() SBE_NOEXCEPT { - return 204; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t flowScheduleTypeEncodingOffset() SBE_NOEXCEPT + { + return 204; + } - static SBE_CONSTEXPR std::int8_t flowScheduleTypeNullValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t flowScheduleTypeNullValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::int8_t flowScheduleTypeMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } + static SBE_CONSTEXPR std::int8_t flowScheduleTypeMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } - static SBE_CONSTEXPR std::int8_t flowScheduleTypeMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t flowScheduleTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::size_t - flowScheduleTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t flowScheduleTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::int8_t flowScheduleType() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 204, sizeof(std::int8_t)); - return (val); - } + SBE_NODISCARD std::int8_t flowScheduleType() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 204, sizeof(std::int8_t)); + return (val); + } - MDInstrumentDefinitionFuture27 & - flowScheduleType(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 204, &val, sizeof(std::int8_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &flowScheduleType(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 204, &val, sizeof(std::int8_t)); + return *this; + } - SBE_NODISCARD static const char *MinPriceIncrementAmountMetaAttribute( - 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 *MinPriceIncrementAmountMetaAttribute(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 minPriceIncrementAmountId() SBE_NOEXCEPT { - return 1146; - } + static SBE_CONSTEXPR std::uint16_t minPriceIncrementAmountId() SBE_NOEXCEPT + { + return 1146; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minPriceIncrementAmountSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minPriceIncrementAmountSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minPriceIncrementAmountInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minPriceIncrementAmountInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minPriceIncrementAmountSinceVersion(); + return m_actingVersion >= minPriceIncrementAmountSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minPriceIncrementAmountEncodingOffset() SBE_NOEXCEPT { - return 205; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minPriceIncrementAmountEncodingOffset() SBE_NOEXCEPT + { + return 205; + } - private: - PRICENULL m_minPriceIncrementAmount; +private: + PRICENULL m_minPriceIncrementAmount; - public: - SBE_NODISCARD PRICENULL &minPriceIncrementAmount() { - m_minPriceIncrementAmount.wrap( - m_buffer, m_offset + 205, m_actingVersion, m_bufferLength); - return m_minPriceIncrementAmount; - } +public: + SBE_NODISCARD PRICENULL &minPriceIncrementAmount() + { + m_minPriceIncrementAmount.wrap(m_buffer, m_offset + 205, m_actingVersion, m_bufferLength); + return m_minPriceIncrementAmount; + } - SBE_NODISCARD static const char *UserDefinedInstrumentMetaAttribute( - 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 *UserDefinedInstrumentMetaAttribute(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 userDefinedInstrumentId() SBE_NOEXCEPT { - return 9779; - } + static SBE_CONSTEXPR std::uint16_t userDefinedInstrumentId() SBE_NOEXCEPT + { + return 9779; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - userDefinedInstrumentSinceVersion() SBE_NOEXCEPT { - return 3; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t userDefinedInstrumentSinceVersion() SBE_NOEXCEPT + { + return 3; + } - SBE_NODISCARD bool userDefinedInstrumentInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool userDefinedInstrumentInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= userDefinedInstrumentSinceVersion(); + return m_actingVersion >= userDefinedInstrumentSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - userDefinedInstrumentEncodingOffset() SBE_NOEXCEPT { - return 213; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t userDefinedInstrumentEncodingOffset() SBE_NOEXCEPT + { + return 213; + } - static SBE_CONSTEXPR char userDefinedInstrumentNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char userDefinedInstrumentNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char userDefinedInstrumentMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char userDefinedInstrumentMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char userDefinedInstrumentMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char userDefinedInstrumentMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - userDefinedInstrumentEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t userDefinedInstrumentEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD char userDefinedInstrument() const SBE_NOEXCEPT { - if (m_actingVersion < 3) { - return (char)0; - } + SBE_NODISCARD char userDefinedInstrument() const SBE_NOEXCEPT + { + if (m_actingVersion < 3) + { + return static_cast(0); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 213, sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 213, sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture27 & - userDefinedInstrument(const char value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 213, &val, sizeof(char)); - return *this; - } + MDInstrumentDefinitionFuture27 &userDefinedInstrument(const char value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 213, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char *TradingReferenceDateMetaAttribute( - 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 *TradingReferenceDateMetaAttribute(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 tradingReferenceDateId() SBE_NOEXCEPT { - return 5796; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateId() SBE_NOEXCEPT + { + return 5796; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingReferenceDateSinceVersion() SBE_NOEXCEPT { - return 6; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingReferenceDateSinceVersion() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tradingReferenceDateSinceVersion(); + return m_actingVersion >= tradingReferenceDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingOffset() SBE_NOEXCEPT { - return 214; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingOffset() SBE_NOEXCEPT + { + return 214; + } - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t tradingReferenceDate() const SBE_NOEXCEPT { - if (m_actingVersion < 6) { - return (std::uint16_t)65535; - } + SBE_NODISCARD std::uint16_t tradingReferenceDate() const SBE_NOEXCEPT + { + if (m_actingVersion < 6) + { + return static_cast(65535); + } - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 214, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 214, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - MDInstrumentDefinitionFuture27 & - tradingReferenceDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 214, &val, sizeof(std::uint16_t)); - return *this; - } + MDInstrumentDefinitionFuture27 &tradingReferenceDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 214, &val, sizeof(std::uint16_t)); + return *this; + } - class NoEvents { + class NoEvents + { 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 NoEvents &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(static_cast(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 *EventTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t eventTypeId() SBE_NOEXCEPT + { + return 865; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t eventTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool eventTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= eventTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t eventTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t eventTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD EventType::Value eventType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint8_t)); + return EventType::get((val)); + } + + NoEvents &eventType(const EventType::Value 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 *EventTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t eventTimeId() SBE_NOEXCEPT + { + return 1145; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t eventTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool eventTimeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= eventTimeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t eventTimeEncodingOffset() SBE_NOEXCEPT + { + return 1; + } + + static SBE_CONSTEXPR std::uint64_t eventTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t eventTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t eventTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t eventTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t eventTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoEvents &eventTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint64_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoEvents writer) + { + builder << '{'; + builder << R"("EventType": )"; + builder << '"' << writer.eventType() << '"'; + + builder << ", "; + builder << R"("EventTime": )"; + builder << +writer.eventTime(); + + 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: + NoEvents m_noEvents; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 9; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoEventsId() SBE_NOEXCEPT + { + return 864; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoEvents &noEvents() + { + m_noEvents.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noEvents; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoEvents &noEventsCount(const std::uint8_t count) + { + m_noEvents.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noEvents; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noEventsSinceVersion() 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 NoEvents &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 * - EventTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t eventTypeId() SBE_NOEXCEPT { - return 865; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - eventTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool eventTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noEventsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= eventTypeSinceVersion(); + return m_actingVersion >= noEventsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - eventTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - eventTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD EventType::Value eventType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint8_t)); - return EventType::get((val)); - } - - NoEvents &eventType(const EventType::Value 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 * - EventTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t eventTimeId() SBE_NOEXCEPT { - return 1145; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - eventTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool eventTimeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= eventTimeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - eventTimeEncodingOffset() SBE_NOEXCEPT { - return 1; - } - - static SBE_CONSTEXPR std::uint64_t eventTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t eventTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t eventTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t eventTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t eventTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoEvents &eventTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint64_t)); - return *this; - } - - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoEvents writer) { - builder << '{'; - builder << R"("EventType": )"; - builder << '"' << writer.eventType() << '"'; - - builder << ", "; - builder << R"("EventTime": )"; - builder << +writer.eventTime(); - - builder << '}'; - - return builder; - } - }; - - private: - NoEvents m_noEvents; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoEventsId() SBE_NOEXCEPT { - return 864; - } - - SBE_NODISCARD inline NoEvents &noEvents() { - m_noEvents.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noEvents; - } - - NoEvents &noEventsCount(const std::uint8_t count) { - m_noEvents.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noEvents; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noEventsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noEventsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noEventsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoMDFeedTypes { + class NoMDFeedTypes + { 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)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 { 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 < m_count; - } - - inline NoMDFeedTypes &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 * - MDFeedTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDFeedTypeId() SBE_NOEXCEPT { - return 1022; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDFeedTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDFeedTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDFeedTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDFeedTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR char mDFeedTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char mDFeedTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char mDFeedTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t mDFeedTypeEncodingLength() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t mDFeedTypeLength() SBE_NOEXCEPT { - return 3; - } - - SBE_NODISCARD const char *mDFeedType() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char *mDFeedType() SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char mDFeedType(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error( - "index out of range for mDFeedType [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } - - NoMDFeedTypes &mDFeedType(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error( - "index out of range for mDFeedType [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getMDFeedType(char *const dst, const std::uint64_t length) const { - if (length > 3) { - throw std::runtime_error( - "length too large for getMDFeedType [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } - - NoMDFeedTypes &putMDFeedType(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 3); - return *this; - } - - NoMDFeedTypes & - putMDFeedType(const char value0, const char value1, const char value2) - SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 0, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 1, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 2, &val2, sizeof(char)); - - return *this; - } - - std::string getMDFeedTypeAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 3 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getMDFeedTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getMDFeedTypeAsString(); - - 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; - } + 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(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; + } - return oss.str(); - } + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } -#if __cplusplus >= 201703L - std::string_view getMDFeedTypeAsStringView() 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 4; + } - for (; length < 3 && *(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 - NoMDFeedTypes &putMDFeedType(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putMDFeedType [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 < 3; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - return *this; - } -#else - NoMDFeedTypes &putMDFeedType(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putMDFeedType [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 < 3; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + inline NoMDFeedTypes &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 * - MarketDepthMetaAttribute(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() SBE_NOEXCEPT + { + 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 marketDepthId() SBE_NOEXCEPT { - return 264; - } + #if __cplusplus < 201103L + template inline void forEach(Func& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - marketDepthSinceVersion() SBE_NOEXCEPT { - return 0; - } + #else + template inline void forEach(Func&& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - SBE_NODISCARD bool marketDepthInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= marketDepthSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + #endif - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - marketDepthEncodingOffset() SBE_NOEXCEPT { - return 3; - } + SBE_NODISCARD static const char *MDFeedTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::int8_t marketDepthNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } + static SBE_CONSTEXPR std::uint16_t mDFeedTypeId() SBE_NOEXCEPT + { + return 1022; + } - static SBE_CONSTEXPR std::int8_t marketDepthMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDFeedTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::int8_t marketDepthMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + SBE_NODISCARD bool mDFeedTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDFeedTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - static SBE_CONSTEXPR std::size_t - marketDepthEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDFeedTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD std::int8_t marketDepth() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 3, sizeof(std::int8_t)); - return (val); - } + static SBE_CONSTEXPR char mDFeedTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - NoMDFeedTypes &marketDepth(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 3, &val, sizeof(std::int8_t)); - return *this; - } + static SBE_CONSTEXPR char mDFeedTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDFeedTypes writer) { - builder << '{'; - builder << R"("MDFeedType": )"; - builder << '"' << writer.getMDFeedTypeAsJsonEscapedString().c_str() - << '"'; + static SBE_CONSTEXPR char mDFeedTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - builder << ", "; - builder << R"("MarketDepth": )"; - builder << +writer.marketDepth(); + static SBE_CONSTEXPR std::size_t mDFeedTypeEncodingLength() SBE_NOEXCEPT + { + return 3; + } - builder << '}'; + static SBE_CONSTEXPR std::uint64_t mDFeedTypeLength() SBE_NOEXCEPT + { + return 3; + } - return builder; - } - }; + SBE_NODISCARD const char *mDFeedType() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - private: - NoMDFeedTypes m_noMDFeedTypes; + SBE_NODISCARD char *mDFeedType() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDFeedTypesId() SBE_NOEXCEPT { - return 1141; - } + SBE_NODISCARD char mDFeedType(const std::uint64_t index) const + { + if (index >= 3) + { + throw std::runtime_error("index out of range for mDFeedType [E104]"); + } - SBE_NODISCARD inline NoMDFeedTypes &noMDFeedTypes() { - m_noMDFeedTypes.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDFeedTypes; - } + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } - NoMDFeedTypes &noMDFeedTypesCount(const std::uint8_t count) { - m_noMDFeedTypes.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDFeedTypes; - } + NoMDFeedTypes &mDFeedType(const std::uint64_t index, const char value) + { + if (index >= 3) + { + throw std::runtime_error("index out of range for mDFeedType [E105]"); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDFeedTypesSinceVersion() SBE_NOEXCEPT { - return 0; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } - SBE_NODISCARD bool noMDFeedTypesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDFeedTypesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + std::uint64_t getMDFeedType(char *const dst, const std::uint64_t length) const + { + if (length > 3) + { + throw std::runtime_error("length too large for getMDFeedType [E106]"); + } - class NoInstAttrib { - 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; + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + NoMDFeedTypes &putMDFeedType(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 3); + return *this; + } - 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; - } + NoMDFeedTypes &putMDFeedType( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 0, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 1, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 2, &val2, sizeof(char)); - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + return *this; + } + + SBE_NODISCARD std::string getMDFeedTypeAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + size_t length = 0; + + for (; length < 3 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getMDFeedTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getMDFeedTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + 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 getMDFeedTypeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + size_t length = 0; + + for (; length < 3 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoMDFeedTypes &putMDFeedType(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putMDFeedType [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #else + NoMDFeedTypes &putMDFeedType(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putMDFeedType [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *MarketDepthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t marketDepthId() SBE_NOEXCEPT + { + return 264; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t marketDepthSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool marketDepthInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= marketDepthSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t marketDepthEncodingOffset() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::int8_t marketDepthNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t marketDepthMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t marketDepthMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t marketDepthEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::int8_t marketDepth() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 3, sizeof(std::int8_t)); + return (val); + } + + NoMDFeedTypes &marketDepth(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 3, &val, sizeof(std::int8_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDFeedTypes writer) + { + builder << '{'; + builder << R"("MDFeedType": )"; + builder << '"' << + writer.getMDFeedTypeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("MarketDepth": )"; + builder << +writer.marketDepth(); + + 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)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; - } +private: + NoMDFeedTypes m_noMDFeedTypes; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 4; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDFeedTypesId() SBE_NOEXCEPT + { + return 1141; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDFeedTypes &noMDFeedTypes() + { + m_noMDFeedTypes.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDFeedTypes; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDFeedTypes &noMDFeedTypesCount(const std::uint8_t count) + { + m_noMDFeedTypes.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDFeedTypes; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDFeedTypesSinceVersion() 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 NoInstAttrib &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 *InstAttribTypeMetaAttribute( - 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 instAttribTypeId() SBE_NOEXCEPT { - return 871; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - instAttribTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool instAttribTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noMDFeedTypesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= instAttribTypeSinceVersion(); + return m_actingVersion >= noMDFeedTypesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - instAttribTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int8_t instAttribTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t instAttribTypeMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t instAttribTypeMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t - instAttribTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::int8_t - instAttribType() SBE_NOEXCEPT { - return (std::int8_t)24; - } - - SBE_NODISCARD static const char *InstAttribValueMetaAttribute( - 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 instAttribValueId() SBE_NOEXCEPT { - return 872; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - instAttribValueSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool instAttribValueInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= instAttribValueSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - instAttribValueEncodingOffset() SBE_NOEXCEPT { - return 0; - } + } + class NoInstAttrib + { private: - InstAttribValue m_instAttribValue; + 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 InstAttribValue &instAttribValue() { - m_instAttribValue.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_instAttribValue; - } + 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; + } - static SBE_CONSTEXPR std::size_t - instAttribValueEncodingLength() SBE_NOEXCEPT { - return 4; - } + 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(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; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoInstAttrib writer) { - builder << '{'; - builder << R"("InstAttribValue": )"; - builder << writer.instAttribValue(); + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } - builder << '}'; + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 4; + } - return builder; - } - }; + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - private: - NoInstAttrib m_noInstAttrib; + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoInstAttribId() SBE_NOEXCEPT { - return 870; - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - SBE_NODISCARD inline NoInstAttrib &noInstAttrib() { - m_noInstAttrib.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noInstAttrib; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - NoInstAttrib &noInstAttribCount(const std::uint8_t count) { - m_noInstAttrib.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noInstAttrib; - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noInstAttribSinceVersion() SBE_NOEXCEPT { - return 0; - } + inline NoInstAttrib &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 bool noInstAttribInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noInstAttribSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + 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(static_cast(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 *InstAttribTypeMetaAttribute(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 instAttribTypeId() SBE_NOEXCEPT + { + return 871; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t instAttribTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool instAttribTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= instAttribTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t instAttribTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::int8_t instAttribTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t instAttribTypeMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t instAttribTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t instAttribTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::int8_t instAttribType() SBE_NOEXCEPT + { + return static_cast(24); + } + + SBE_NODISCARD static const char *InstAttribValueMetaAttribute(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 instAttribValueId() SBE_NOEXCEPT + { + return 872; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t instAttribValueSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool instAttribValueInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= instAttribValueSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t instAttribValueEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - class NoLotTypeRules { 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; - } + InstAttribValue m_instAttribValue; 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; - } + SBE_NODISCARD InstAttribValue &instAttribValue() + { + m_instAttribValue.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_instAttribValue; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + static SBE_CONSTEXPR std::size_t instAttribValueEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoInstAttrib writer) + { + builder << '{'; + builder << R"("InstAttribValue": )"; + builder << writer.instAttribValue(); + + 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)5); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 5; - 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: + NoInstAttrib m_noInstAttrib; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 5; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoInstAttribId() SBE_NOEXCEPT + { + return 870; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoInstAttrib &noInstAttrib() + { + m_noInstAttrib.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noInstAttrib; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoInstAttrib &noInstAttribCount(const std::uint8_t count) + { + m_noInstAttrib.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noInstAttrib; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noInstAttribSinceVersion() 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 NoLotTypeRules &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 * - LotTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t lotTypeId() SBE_NOEXCEPT { - return 1093; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lotTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lotTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noInstAttribInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lotTypeSinceVersion(); + return m_actingVersion >= noInstAttribSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lotTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int8_t lotTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t lotTypeMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t lotTypeMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t lotTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::int8_t lotType() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int8_t)); - return (val); - } - - NoLotTypeRules &lotType(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int8_t)); - return *this; - } - - SBE_NODISCARD static const char * - MinLotSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t minLotSizeId() SBE_NOEXCEPT { - return 1231; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minLotSizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool minLotSizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= minLotSizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minLotSizeEncodingOffset() SBE_NOEXCEPT { - return 1; - } + } + class NoLotTypeRules + { private: - DecimalQty m_minLotSize; + 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 DecimalQty &minLotSize() { - m_minLotSize.wrap( - m_buffer, m_offset + 1, m_actingVersion, m_bufferLength); - return m_minLotSize; - } + 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; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoLotTypeRules writer) { - builder << '{'; - builder << R"("LotType": )"; - builder << +writer.lotType(); + 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(5)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 5; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - builder << ", "; - builder << R"("MinLotSize": )"; - builder << writer.minLotSize(); + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } - builder << '}'; + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 5; + } - return builder; - } - }; + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - private: - NoLotTypeRules m_noLotTypeRules; + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoLotTypeRulesId() SBE_NOEXCEPT { - return 1234; - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - SBE_NODISCARD inline NoLotTypeRules &noLotTypeRules() { - m_noLotTypeRules.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLotTypeRules; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - NoLotTypeRules &noLotTypeRulesCount(const std::uint8_t count) { - m_noLotTypeRules.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLotTypeRules; - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noLotTypeRulesSinceVersion() SBE_NOEXCEPT { - return 0; - } + inline NoLotTypeRules &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 bool noLotTypeRulesInActingVersion() const SBE_NOEXCEPT { + 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(static_cast(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 *LotTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lotTypeId() SBE_NOEXCEPT + { + return 1093; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lotTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lotTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= lotTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lotTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::int8_t lotTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t lotTypeMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t lotTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t lotTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::int8_t lotType() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int8_t)); + return (val); + } + + NoLotTypeRules &lotType(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int8_t)); + return *this; + } + + SBE_NODISCARD static const char *MinLotSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t minLotSizeId() SBE_NOEXCEPT + { + return 1231; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minLotSizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool minLotSizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= minLotSizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minLotSizeEncodingOffset() SBE_NOEXCEPT + { + return 1; + } + +private: + DecimalQty m_minLotSize; + +public: + SBE_NODISCARD DecimalQty &minLotSize() + { + m_minLotSize.wrap(m_buffer, m_offset + 1, m_actingVersion, m_bufferLength); + return m_minLotSize; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoLotTypeRules writer) + { + builder << '{'; + builder << R"("LotType": )"; + builder << +writer.lotType(); + + builder << ", "; + builder << R"("MinLotSize": )"; + builder << writer.minLotSize(); + + 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: + NoLotTypeRules m_noLotTypeRules; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoLotTypeRulesId() SBE_NOEXCEPT + { + return 1234; + } + + SBE_NODISCARD inline NoLotTypeRules &noLotTypeRules() + { + m_noLotTypeRules.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLotTypeRules; + } + + NoLotTypeRules &noLotTypeRulesCount(const std::uint8_t count) + { + m_noLotTypeRules.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLotTypeRules; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noLotTypeRulesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noLotTypeRulesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noLotTypeRulesSinceVersion(); + return m_actingVersion >= noLotTypeRulesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDInstrumentDefinitionFuture27 _writer) { - MDInstrumentDefinitionFuture27 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDInstrumentDefinitionFuture27", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDInstrumentDefinitionFuture27 _writer) +{ + MDInstrumentDefinitionFuture27 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDInstrumentDefinitionFuture27", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); - builder << ", "; - builder << R"("TotNumReports": )"; - builder << +writer.totNumReports(); + builder << ", "; + builder << R"("TotNumReports": )"; + builder << +writer.totNumReports(); - builder << ", "; - builder << R"("SecurityUpdateAction": )"; - builder << '"' << writer.securityUpdateAction() << '"'; + builder << ", "; + builder << R"("SecurityUpdateAction": )"; + builder << '"' << writer.securityUpdateAction() << '"'; - builder << ", "; - builder << R"("LastUpdateTime": )"; - builder << +writer.lastUpdateTime(); + builder << ", "; + builder << R"("LastUpdateTime": )"; + builder << +writer.lastUpdateTime(); - builder << ", "; - builder << R"("MDSecurityTradingStatus": )"; - builder << '"' << writer.mDSecurityTradingStatus() << '"'; + builder << ", "; + builder << R"("MDSecurityTradingStatus": )"; + builder << '"' << writer.mDSecurityTradingStatus() << '"'; - builder << ", "; - builder << R"("ApplID": )"; - builder << +writer.applID(); + builder << ", "; + builder << R"("ApplID": )"; + builder << +writer.applID(); - builder << ", "; - builder << R"("MarketSegmentID": )"; - builder << +writer.marketSegmentID(); + builder << ", "; + builder << R"("MarketSegmentID": )"; + builder << +writer.marketSegmentID(); - builder << ", "; - builder << R"("UnderlyingProduct": )"; - builder << +writer.underlyingProduct(); + builder << ", "; + builder << R"("UnderlyingProduct": )"; + builder << +writer.underlyingProduct(); - builder << ", "; - builder << R"("SecurityExchange": )"; - builder << '"' << writer.getSecurityExchangeAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("SecurityExchange": )"; + builder << '"' << + writer.getSecurityExchangeAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("SecurityGroup": )"; - builder << '"' << writer.getSecurityGroupAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("SecurityGroup": )"; + builder << '"' << + writer.getSecurityGroupAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("Asset": )"; - builder << '"' << writer.getAssetAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("Asset": )"; + builder << '"' << + writer.getAssetAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("Symbol": )"; - builder << '"' << writer.getSymbolAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("Symbol": )"; + builder << '"' << + writer.getSymbolAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); - builder << ", "; - builder << R"("SecurityType": )"; - builder << '"' << writer.getSecurityTypeAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("SecurityType": )"; + builder << '"' << + writer.getSecurityTypeAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("CFICode": )"; - builder << '"' << writer.getCFICodeAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("CFICode": )"; + builder << '"' << + writer.getCFICodeAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("MaturityMonthYear": )"; - builder << writer.maturityMonthYear(); + builder << ", "; + builder << R"("MaturityMonthYear": )"; + builder << writer.maturityMonthYear(); - builder << ", "; - builder << R"("Currency": )"; - builder << '"' << writer.getCurrencyAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("Currency": )"; + builder << '"' << + writer.getCurrencyAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("SettlCurrency": )"; - builder << '"' << writer.getSettlCurrencyAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("SettlCurrency": )"; + builder << '"' << + writer.getSettlCurrencyAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("MatchAlgorithm": )"; - if (std::isprint(writer.matchAlgorithm())) { - builder << '"' << (char)writer.matchAlgorithm() << '"'; - } else { - builder << (int)writer.matchAlgorithm(); - } + builder << ", "; + builder << R"("MatchAlgorithm": )"; + if (std::isprint(writer.matchAlgorithm())) + { + builder << '"' << (char)writer.matchAlgorithm() << '"'; + } + else + { + builder << (int)writer.matchAlgorithm(); + } - builder << ", "; - builder << R"("MinTradeVol": )"; - builder << +writer.minTradeVol(); + builder << ", "; + builder << R"("MinTradeVol": )"; + builder << +writer.minTradeVol(); - builder << ", "; - builder << R"("MaxTradeVol": )"; - builder << +writer.maxTradeVol(); + builder << ", "; + builder << R"("MaxTradeVol": )"; + builder << +writer.maxTradeVol(); - builder << ", "; - builder << R"("MinPriceIncrement": )"; - builder << writer.minPriceIncrement(); + builder << ", "; + builder << R"("MinPriceIncrement": )"; + builder << writer.minPriceIncrement(); - builder << ", "; - builder << R"("DisplayFactor": )"; - builder << writer.displayFactor(); + builder << ", "; + builder << R"("DisplayFactor": )"; + builder << writer.displayFactor(); - builder << ", "; - builder << R"("MainFraction": )"; - builder << +writer.mainFraction(); + builder << ", "; + builder << R"("MainFraction": )"; + builder << +writer.mainFraction(); - builder << ", "; - builder << R"("SubFraction": )"; - builder << +writer.subFraction(); + builder << ", "; + builder << R"("SubFraction": )"; + builder << +writer.subFraction(); - builder << ", "; - builder << R"("PriceDisplayFormat": )"; - builder << +writer.priceDisplayFormat(); + builder << ", "; + builder << R"("PriceDisplayFormat": )"; + builder << +writer.priceDisplayFormat(); - builder << ", "; - builder << R"("UnitOfMeasure": )"; - builder << '"' << writer.getUnitOfMeasureAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("UnitOfMeasure": )"; + builder << '"' << + writer.getUnitOfMeasureAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("UnitOfMeasureQty": )"; - builder << writer.unitOfMeasureQty(); + builder << ", "; + builder << R"("UnitOfMeasureQty": )"; + builder << writer.unitOfMeasureQty(); - builder << ", "; - builder << R"("TradingReferencePrice": )"; - builder << writer.tradingReferencePrice(); + builder << ", "; + builder << R"("TradingReferencePrice": )"; + builder << writer.tradingReferencePrice(); - builder << ", "; - builder << R"("SettlPriceType": )"; - builder << writer.settlPriceType(); + builder << ", "; + builder << R"("SettlPriceType": )"; + builder << writer.settlPriceType(); - builder << ", "; - builder << R"("OpenInterestQty": )"; - builder << +writer.openInterestQty(); + builder << ", "; + builder << R"("OpenInterestQty": )"; + builder << +writer.openInterestQty(); - builder << ", "; - builder << R"("ClearedVolume": )"; - builder << +writer.clearedVolume(); + builder << ", "; + builder << R"("ClearedVolume": )"; + builder << +writer.clearedVolume(); - builder << ", "; - builder << R"("HighLimitPrice": )"; - builder << writer.highLimitPrice(); + builder << ", "; + builder << R"("HighLimitPrice": )"; + builder << writer.highLimitPrice(); - builder << ", "; - builder << R"("LowLimitPrice": )"; - builder << writer.lowLimitPrice(); + builder << ", "; + builder << R"("LowLimitPrice": )"; + builder << writer.lowLimitPrice(); - builder << ", "; - builder << R"("MaxPriceVariation": )"; - builder << writer.maxPriceVariation(); + builder << ", "; + builder << R"("MaxPriceVariation": )"; + builder << writer.maxPriceVariation(); - builder << ", "; - builder << R"("DecayQuantity": )"; - builder << +writer.decayQuantity(); + builder << ", "; + builder << R"("DecayQuantity": )"; + builder << +writer.decayQuantity(); - builder << ", "; - builder << R"("DecayStartDate": )"; - builder << +writer.decayStartDate(); + builder << ", "; + builder << R"("DecayStartDate": )"; + builder << +writer.decayStartDate(); - builder << ", "; - builder << R"("OriginalContractSize": )"; - builder << +writer.originalContractSize(); + builder << ", "; + builder << R"("OriginalContractSize": )"; + builder << +writer.originalContractSize(); - builder << ", "; - builder << R"("ContractMultiplier": )"; - builder << +writer.contractMultiplier(); + builder << ", "; + builder << R"("ContractMultiplier": )"; + builder << +writer.contractMultiplier(); - builder << ", "; - builder << R"("ContractMultiplierUnit": )"; - builder << +writer.contractMultiplierUnit(); + builder << ", "; + builder << R"("ContractMultiplierUnit": )"; + builder << +writer.contractMultiplierUnit(); - builder << ", "; - builder << R"("FlowScheduleType": )"; - builder << +writer.flowScheduleType(); + builder << ", "; + builder << R"("FlowScheduleType": )"; + builder << +writer.flowScheduleType(); - builder << ", "; - builder << R"("MinPriceIncrementAmount": )"; - builder << writer.minPriceIncrementAmount(); + builder << ", "; + builder << R"("MinPriceIncrementAmount": )"; + builder << writer.minPriceIncrementAmount(); - builder << ", "; - builder << R"("UserDefinedInstrument": )"; - if (std::isprint(writer.userDefinedInstrument())) { - builder << '"' << (char)writer.userDefinedInstrument() << '"'; - } else { - builder << (int)writer.userDefinedInstrument(); - } + builder << ", "; + builder << R"("UserDefinedInstrument": )"; + if (std::isprint(writer.userDefinedInstrument())) + { + builder << '"' << (char)writer.userDefinedInstrument() << '"'; + } + else + { + builder << (int)writer.userDefinedInstrument(); + } - builder << ", "; - builder << R"("TradingReferenceDate": )"; - builder << +writer.tradingReferenceDate(); + builder << ", "; + builder << R"("TradingReferenceDate": )"; + builder << +writer.tradingReferenceDate(); - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoEvents": [)"; - writer.noEvents().forEach([&](NoEvents &noEvents) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoEvents": [)"; + writer.noEvents().forEach([&](NoEvents& noEvents) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noEvents; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDFeedTypes": [)"; - writer.noMDFeedTypes().forEach([&](NoMDFeedTypes &noMDFeedTypes) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDFeedTypes": [)"; + writer.noMDFeedTypes().forEach([&](NoMDFeedTypes& noMDFeedTypes) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDFeedTypes; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoInstAttrib": [)"; - writer.noInstAttrib().forEach([&](NoInstAttrib &noInstAttrib) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoInstAttrib": [)"; + writer.noInstAttrib().forEach([&](NoInstAttrib& noInstAttrib) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noInstAttrib; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoLotTypeRules": [)"; - writer.noLotTypeRules().forEach([&](NoLotTypeRules &noLotTypeRules) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoLotTypeRules": [)"; + writer.noLotTypeRules().forEach([&](NoLotTypeRules& noLotTypeRules) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noLotTypeRules; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noEvents().forEach([](NoEvents e) + { + e.skip(); + }); + noMDFeedTypes().forEach([](NoMDFeedTypes e) + { + e.skip(); + }); + noInstAttrib().forEach([](NoInstAttrib e) + { + e.skip(); + }); + noLotTypeRules().forEach([](NoLotTypeRules e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noEventsLength = 0, + std::size_t noMDFeedTypesLength = 0, + std::size_t noInstAttribLength = 0, + std::size_t noLotTypeRulesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoEvents::sbeHeaderSize(); + if (noEventsLength > 254LL) + { + throw std::runtime_error("noEventsLength outside of allowed range [E110]"); + } + length += noEventsLength *NoEvents::sbeBlockLength(); + + length += NoMDFeedTypes::sbeHeaderSize(); + if (noMDFeedTypesLength > 254LL) + { + throw std::runtime_error("noMDFeedTypesLength outside of allowed range [E110]"); + } + length += noMDFeedTypesLength *NoMDFeedTypes::sbeBlockLength(); + + length += NoInstAttrib::sbeHeaderSize(); + if (noInstAttribLength > 254LL) + { + throw std::runtime_error("noInstAttribLength outside of allowed range [E110]"); + } + length += noInstAttribLength *NoInstAttrib::sbeBlockLength(); + + length += NoLotTypeRules::sbeHeaderSize(); + if (noLotTypeRulesLength > 254LL) + { + throw std::runtime_error("noLotTypeRulesLength outside of allowed range [E110]"); + } + length += noLotTypeRulesLength *NoLotTypeRules::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionFuture54.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionFuture54.h index 3f2119f68..48755366b 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionFuture54.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionFuture54.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,5881 +86,6394 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDInstrumentDefinitionFuture54 { - 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 MDInstrumentDefinitionFuture54 +{ +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; } + 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(216); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(54); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDInstrumentDefinitionFuture54() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDInstrumentDefinitionFuture54( - 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; - MDInstrumentDefinitionFuture54( - char *buffer, const std::uint64_t bufferLength) - : MDInstrumentDefinitionFuture54( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDInstrumentDefinitionFuture54() = default; - MDInstrumentDefinitionFuture54( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDInstrumentDefinitionFuture54( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDInstrumentDefinitionFuture54( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)216; - } + MDInstrumentDefinitionFuture54(char *buffer, const std::uint64_t bufferLength) : + MDInstrumentDefinitionFuture54(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)54; - } + MDInstrumentDefinitionFuture54( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDInstrumentDefinitionFuture54(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(216); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "d"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(54); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDInstrumentDefinitionFuture54 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDInstrumentDefinitionFuture54( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDInstrumentDefinitionFuture54 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "d"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDInstrumentDefinitionFuture54( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDInstrumentDefinitionFuture54 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDInstrumentDefinitionFuture54(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDInstrumentDefinitionFuture54 &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 = MDInstrumentDefinitionFuture54( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDInstrumentDefinitionFuture54 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDInstrumentDefinitionFuture54( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDInstrumentDefinitionFuture54 &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 = MDInstrumentDefinitionFuture54(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MDInstrumentDefinitionFuture54 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char *MatchEventIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MultipleCharValue"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char * - TotNumReportsMetaAttribute(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 *TotNumReportsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT { - return 911; - } + static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT + { + return 911; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totNumReportsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t totNumReportsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= totNumReportsSinceVersion(); + return m_actingVersion >= totNumReportsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totNumReportsEncodingOffset() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t totNumReportsEncodingOffset() SBE_NOEXCEPT + { + return 1; + } - static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t totNumReports() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t totNumReports() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionFuture54 & - totNumReports(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint32_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &totNumReports(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char *SecurityUpdateActionMetaAttribute( - 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 *SecurityUpdateActionMetaAttribute(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 securityUpdateActionId() SBE_NOEXCEPT { - return 980; - } + static SBE_CONSTEXPR std::uint16_t securityUpdateActionId() SBE_NOEXCEPT + { + return 980; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityUpdateActionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityUpdateActionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityUpdateActionSinceVersion(); + return m_actingVersion >= securityUpdateActionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SecurityUpdateAction::Value - securityUpdateAction() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 5, sizeof(char)); - return SecurityUpdateAction::get((val)); - } + SBE_NODISCARD SecurityUpdateAction::Value securityUpdateAction() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 5, sizeof(char)); + return SecurityUpdateAction::get((val)); + } - MDInstrumentDefinitionFuture54 & - securityUpdateAction(const SecurityUpdateAction::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 5, &val, sizeof(char)); - return *this; - } + MDInstrumentDefinitionFuture54 &securityUpdateAction(const SecurityUpdateAction::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 5, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char * - LastUpdateTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LastUpdateTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t lastUpdateTimeId() SBE_NOEXCEPT { - return 779; - } + static SBE_CONSTEXPR std::uint16_t lastUpdateTimeId() SBE_NOEXCEPT + { + return 779; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastUpdateTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastUpdateTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lastUpdateTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lastUpdateTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastUpdateTimeSinceVersion(); + return m_actingVersion >= lastUpdateTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastUpdateTimeEncodingOffset() SBE_NOEXCEPT { - return 6; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastUpdateTimeEncodingOffset() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - lastUpdateTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t lastUpdateTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t lastUpdateTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 6, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t lastUpdateTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 6, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MDInstrumentDefinitionFuture54 & - lastUpdateTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 6, &val, sizeof(std::uint64_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &lastUpdateTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 6, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *MDSecurityTradingStatusMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MDSecurityTradingStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mDSecurityTradingStatusId() SBE_NOEXCEPT { - return 1682; - } + static SBE_CONSTEXPR std::uint16_t mDSecurityTradingStatusId() SBE_NOEXCEPT + { + return 1682; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDSecurityTradingStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDSecurityTradingStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mDSecurityTradingStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mDSecurityTradingStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDSecurityTradingStatusSinceVersion(); + return m_actingVersion >= mDSecurityTradingStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDSecurityTradingStatusEncodingOffset() SBE_NOEXCEPT { - return 14; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDSecurityTradingStatusEncodingOffset() SBE_NOEXCEPT + { + return 14; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDSecurityTradingStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDSecurityTradingStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SecurityTradingStatus::Value - mDSecurityTradingStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); - return SecurityTradingStatus::get((val)); - } + SBE_NODISCARD SecurityTradingStatus::Value mDSecurityTradingStatus() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); + return SecurityTradingStatus::get((val)); + } - MDInstrumentDefinitionFuture54 &mDSecurityTradingStatus( - const SecurityTradingStatus::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &mDSecurityTradingStatus(const SecurityTradingStatus::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - ApplIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ApplIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t applIDId() SBE_NOEXCEPT { return 1180; } + static SBE_CONSTEXPR std::uint16_t applIDId() SBE_NOEXCEPT + { + return 1180; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - applIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t applIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool applIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool applIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= applIDSinceVersion(); + return m_actingVersion >= applIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - applIDEncodingOffset() SBE_NOEXCEPT { - return 15; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t applIDEncodingOffset() SBE_NOEXCEPT + { + return 15; + } - static SBE_CONSTEXPR std::int16_t applIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT16; - } + static SBE_CONSTEXPR std::int16_t applIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT16; + } - static SBE_CONSTEXPR std::int16_t applIDMinValue() SBE_NOEXCEPT { - return (std::int16_t)-32767; - } + static SBE_CONSTEXPR std::int16_t applIDMinValue() SBE_NOEXCEPT + { + return static_cast(-32767); + } - static SBE_CONSTEXPR std::int16_t applIDMaxValue() SBE_NOEXCEPT { - return (std::int16_t)32767; - } + static SBE_CONSTEXPR std::int16_t applIDMaxValue() SBE_NOEXCEPT + { + return static_cast(32767); + } - static SBE_CONSTEXPR std::size_t applIDEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t applIDEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::int16_t applID() const SBE_NOEXCEPT { - std::int16_t val; - std::memcpy(&val, m_buffer + m_offset + 15, sizeof(std::int16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::int16_t applID() const SBE_NOEXCEPT + { + std::int16_t val; + std::memcpy(&val, m_buffer + m_offset + 15, sizeof(std::int16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - MDInstrumentDefinitionFuture54 & - applID(const std::int16_t value) SBE_NOEXCEPT { - std::int16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 15, &val, sizeof(std::int16_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &applID(const std::int16_t value) SBE_NOEXCEPT + { + std::int16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 15, &val, sizeof(std::int16_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 "required"; - 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 "required"; + 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 17; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t marketSegmentIDEncodingOffset() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } - 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 + 17, 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 + 17, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionFuture54 & - marketSegmentID(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &marketSegmentID(const std::uint8_t 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 *UnderlyingProductMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UnderlyingProductMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t underlyingProductId() SBE_NOEXCEPT { - return 462; - } + static SBE_CONSTEXPR std::uint16_t underlyingProductId() SBE_NOEXCEPT + { + return 462; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - underlyingProductSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t underlyingProductSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool underlyingProductInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool underlyingProductInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= underlyingProductSinceVersion(); + return m_actingVersion >= underlyingProductSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - underlyingProductEncodingOffset() SBE_NOEXCEPT { - return 18; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t underlyingProductEncodingOffset() SBE_NOEXCEPT + { + return 18; + } - static SBE_CONSTEXPR std::uint8_t underlyingProductNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR std::uint8_t underlyingProductNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } - static SBE_CONSTEXPR std::uint8_t underlyingProductMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t underlyingProductMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t underlyingProductMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t underlyingProductMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - underlyingProductEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t underlyingProductEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t underlyingProduct() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t underlyingProduct() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionFuture54 & - underlyingProduct(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; - } + MDInstrumentDefinitionFuture54 &underlyingProduct(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 static const char *SecurityExchangeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Exchange"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityExchangeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Exchange"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityExchangeId() SBE_NOEXCEPT { - return 207; - } + static SBE_CONSTEXPR std::uint16_t securityExchangeId() SBE_NOEXCEPT + { + return 207; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityExchangeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityExchangeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityExchangeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityExchangeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityExchangeSinceVersion(); + return m_actingVersion >= securityExchangeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityExchangeEncodingOffset() SBE_NOEXCEPT { - return 19; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityExchangeEncodingOffset() SBE_NOEXCEPT + { + return 19; + } - static SBE_CONSTEXPR char securityExchangeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityExchangeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityExchangeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityExchangeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityExchangeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char securityExchangeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - securityExchangeEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityExchangeEncodingLength() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t securityExchangeLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::uint64_t securityExchangeLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD const char *securityExchange() const SBE_NOEXCEPT { - return m_buffer + m_offset + 19; - } + SBE_NODISCARD const char *securityExchange() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 19; + } - SBE_NODISCARD char *securityExchange() SBE_NOEXCEPT { - return m_buffer + m_offset + 19; - } + SBE_NODISCARD char *securityExchange() SBE_NOEXCEPT + { + return m_buffer + m_offset + 19; + } - SBE_NODISCARD char securityExchange(const std::uint64_t index) const { - if (index >= 4) { - throw std::runtime_error( - "index out of range for securityExchange [E104]"); - } + SBE_NODISCARD char securityExchange(const std::uint64_t index) const + { + if (index >= 4) + { + throw std::runtime_error("index out of range for securityExchange [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 19 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 19 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture54 & - securityExchange(const std::uint64_t index, const char value) { - if (index >= 4) { - throw std::runtime_error( - "index out of range for securityExchange [E105]"); - } + MDInstrumentDefinitionFuture54 &securityExchange(const std::uint64_t index, const char value) + { + if (index >= 4) + { + throw std::runtime_error("index out of range for securityExchange [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 19 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 19 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSecurityExchange(char *const dst, const std::uint64_t length) const { - if (length > 4) { - throw std::runtime_error( - "length too large for getSecurityExchange [E106]"); - } + std::uint64_t getSecurityExchange(char *const dst, const std::uint64_t length) const + { + if (length > 4) + { + throw std::runtime_error("length too large for getSecurityExchange [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 19, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 19, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionFuture54 & - putSecurityExchange(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 19, src, sizeof(char) * 4); - return *this; - } + MDInstrumentDefinitionFuture54 &putSecurityExchange(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 19, src, sizeof(char) * 4); + return *this; + } - MDInstrumentDefinitionFuture54 &putSecurityExchange( - const char value0, - const char value1, - const char value2, - const char value3) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 19, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 20, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 21, &val2, sizeof(char)); - char val3 = (value3); - std::memcpy(m_buffer + m_offset + 22, &val3, sizeof(char)); + MDInstrumentDefinitionFuture54 &putSecurityExchange( + const char value0, + const char value1, + const char value2, + const char value3) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 19, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 20, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 21, &val2, sizeof(char)); + char val3 = (value3); + std::memcpy(m_buffer + m_offset + 22, &val3, sizeof(char)); - return *this; - } + return *this; + } - std::string getSecurityExchangeAsString() const { - const char *buffer = m_buffer + m_offset + 19; - size_t length = 0; + SBE_NODISCARD std::string getSecurityExchangeAsString() const + { + const char *buffer = m_buffer + m_offset + 19; + size_t length = 0; - for (; length < 4 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 4 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSecurityExchangeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityExchangeAsString(); + std::string getSecurityExchangeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityExchangeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityExchangeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 19; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityExchangeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 19; + size_t length = 0; - for (; length < 4 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 4 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - MDInstrumentDefinitionFuture54 & - putSecurityExchange(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 4) { - throw std::runtime_error( - "string too large for putSecurityExchange [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionFuture54 &putSecurityExchange(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 4) + { + throw std::runtime_error("string too large for putSecurityExchange [E106]"); + } - std::memcpy(m_buffer + m_offset + 19, str.data(), srcLength); - for (size_t start = srcLength; start < 4; ++start) { - m_buffer[m_offset + 19 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 19, str.data(), srcLength); + for (size_t start = srcLength; start < 4; ++start) + { + m_buffer[m_offset + 19 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionFuture54 &putSecurityExchange(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 4) { - throw std::runtime_error( - "string too large for putSecurityExchange [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionFuture54 &putSecurityExchange(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 4) + { + throw std::runtime_error("string too large for putSecurityExchange [E106]"); + } - std::memcpy(m_buffer + m_offset + 19, str.c_str(), srcLength); - for (size_t start = srcLength; start < 4; ++start) { - m_buffer[m_offset + 19 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 19, str.c_str(), srcLength); + for (size_t start = srcLength; start < 4; ++start) + { + m_buffer[m_offset + 19 + start] = 0; + } - return *this; - } -#endif + return *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 "required"; - 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 "required"; + 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 23; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityGroupEncodingOffset() SBE_NOEXCEPT + { + return 23; + } - 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 + 23; - } + SBE_NODISCARD const char *securityGroup() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 23; + } - SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT { - return m_buffer + m_offset + 23; - } + SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT + { + return m_buffer + m_offset + 23; + } - 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 + 23 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 23 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture54 & - securityGroup(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E105]"); - } + MDInstrumentDefinitionFuture54 &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 + 23 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 23 + (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 + 23, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 23, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionFuture54 & - putSecurityGroup(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 23, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionFuture54 &putSecurityGroup(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 23, src, sizeof(char) * 6); + return *this; + } - std::string getSecurityGroupAsString() const { - const char *buffer = m_buffer + m_offset + 23; - size_t length = 0; + SBE_NODISCARD std::string getSecurityGroupAsString() const + { + const char *buffer = m_buffer + m_offset + 23; + 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 (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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityGroupAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 23; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 23; + 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 - MDInstrumentDefinitionFuture54 & - 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 + MDInstrumentDefinitionFuture54 &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 + 23, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 23 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 23, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 23 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionFuture54 &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 + MDInstrumentDefinitionFuture54 &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 + 23, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 23 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 23, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 23 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - AssetMetaAttribute(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 *AssetMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t assetId() SBE_NOEXCEPT { return 6937; } + static SBE_CONSTEXPR std::uint16_t assetId() SBE_NOEXCEPT + { + return 6937; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - assetSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t assetSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool assetInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool assetInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= assetSinceVersion(); + return m_actingVersion >= assetSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - assetEncodingOffset() SBE_NOEXCEPT { - return 29; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t assetEncodingOffset() SBE_NOEXCEPT + { + return 29; + } - static SBE_CONSTEXPR char assetNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char assetNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char assetMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char assetMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char assetMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char assetMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t assetEncodingLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::size_t assetEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t assetLength() SBE_NOEXCEPT { return 6; } + static SBE_CONSTEXPR std::uint64_t assetLength() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD const char *asset() const SBE_NOEXCEPT { - return m_buffer + m_offset + 29; - } + SBE_NODISCARD const char *asset() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 29; + } - SBE_NODISCARD char *asset() SBE_NOEXCEPT { return m_buffer + m_offset + 29; } + SBE_NODISCARD char *asset() SBE_NOEXCEPT + { + return m_buffer + m_offset + 29; + } - SBE_NODISCARD char asset(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for asset [E104]"); - } + SBE_NODISCARD char asset(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for asset [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 29 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 29 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture54 & - asset(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for asset [E105]"); - } + MDInstrumentDefinitionFuture54 &asset(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for asset [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 29 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 29 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getAsset(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error("length too large for getAsset [E106]"); - } + std::uint64_t getAsset(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getAsset [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 29, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 29, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionFuture54 & - putAsset(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 29, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionFuture54 &putAsset(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 29, src, sizeof(char) * 6); + return *this; + } - std::string getAssetAsString() const { - const char *buffer = m_buffer + m_offset + 29; - size_t length = 0; + SBE_NODISCARD std::string getAssetAsString() const + { + const char *buffer = m_buffer + m_offset + 29; + 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 getAssetAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getAssetAsString(); + std::string getAssetAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getAssetAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getAssetAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 29; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getAssetAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 29; + 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 - MDInstrumentDefinitionFuture54 &putAsset(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putAsset [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionFuture54 &putAsset(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putAsset [E106]"); + } - std::memcpy(m_buffer + m_offset + 29, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 29 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 29, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 29 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionFuture54 &putAsset(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putAsset [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionFuture54 &putAsset(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putAsset [E106]"); + } - std::memcpy(m_buffer + m_offset + 29, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 29 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 29, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 29 + start] = 0; + } - return *this; - } -#endif + 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 "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SymbolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t symbolId() SBE_NOEXCEPT { return 55; } + 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 static SBE_CONSTEXPR std::uint64_t symbolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool symbolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool symbolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= symbolSinceVersion(); + return m_actingVersion >= symbolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - symbolEncodingOffset() SBE_NOEXCEPT { - return 35; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t symbolEncodingOffset() SBE_NOEXCEPT + { + return 35; + } - static SBE_CONSTEXPR char symbolNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char symbolNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char symbolMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char symbolMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char symbolMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char symbolMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t symbolEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t symbolEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t symbolLength() 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 + 35; - } + SBE_NODISCARD const char *symbol() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 35; + } - SBE_NODISCARD char *symbol() SBE_NOEXCEPT { - return m_buffer + m_offset + 35; - } + SBE_NODISCARD char *symbol() SBE_NOEXCEPT + { + return m_buffer + m_offset + 35; + } - SBE_NODISCARD char symbol(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for symbol [E104]"); - } + 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 + 35 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 35 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture54 & - symbol(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for symbol [E105]"); - } + MDInstrumentDefinitionFuture54 &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 + 35 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 35 + (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::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 + 35, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 35, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionFuture54 & - putSymbol(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 35, src, sizeof(char) * 20); - return *this; - } + MDInstrumentDefinitionFuture54 &putSymbol(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 35, src, sizeof(char) * 20); + return *this; + } - std::string getSymbolAsString() const { - const char *buffer = m_buffer + m_offset + 35; - size_t length = 0; + SBE_NODISCARD std::string getSymbolAsString() const + { + const char *buffer = m_buffer + m_offset + 35; + 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 getSymbolAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSymbolAsString(); + std::string getSymbolAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSymbolAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSymbolAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 35; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSymbolAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 35; + 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 - MDInstrumentDefinitionFuture54 &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]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionFuture54 &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 + 35, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 35 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 35, str.data(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 35 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionFuture54 &putSymbol(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSymbol [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionFuture54 &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 + 35, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 35 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 35, str.c_str(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 35 + 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 55; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 55; + } - 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 + 55, 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 + 55, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionFuture54 & - securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 55, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 55, &val, sizeof(std::int32_t)); + return *this; + } - 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 ""; - } - } + 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; - } + 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 static SBE_CONSTEXPR std::uint64_t securityIDSourceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDSourceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDSourceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSourceSinceVersion(); + return m_actingVersion >= securityIDSourceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDSourceEncodingOffset() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDSourceEncodingOffset() SBE_NOEXCEPT + { + return 59; + } - static SBE_CONSTEXPR char securityIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityIDSourceNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityIDSourceMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityIDSourceMaxValue() SBE_NOEXCEPT { - return (char)126; - } + 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::size_t securityIDSourceEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t securityIDSourceLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t securityIDSourceLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *securityIDSource() const { - static const std::uint8_t securityIDSourceValues[] = {56}; + SBE_NODISCARD const char *securityIDSource() const + { + static const std::uint8_t securityIDSourceValues[] = { 56 }; - return (const char *)securityIDSourceValues; - } + return (const char *)securityIDSourceValues; + } - SBE_NODISCARD char securityIDSource(const std::uint64_t index) const { - static const std::uint8_t securityIDSourceValues[] = {56}; + SBE_NODISCARD char securityIDSource(const std::uint64_t index) const + { + static const std::uint8_t securityIDSourceValues[] = { 56 }; - return (char)securityIDSourceValues[index]; - } + 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::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::memcpy(dst, securityIDSourceValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getSecurityIDSourceAsString() const { - static const std::uint8_t SecurityIDSourceValues[] = {56}; + std::string getSecurityIDSourceAsString() const + { + static const std::uint8_t SecurityIDSourceValues[] = { 56 }; - return std::string((const char *)SecurityIDSourceValues, 1); - } + return std::string((const char *)SecurityIDSourceValues, 1); + } - std::string getSecurityIDSourceAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityIDSourceAsString(); + std::string getSecurityIDSourceAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityIDSourceAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 * - SecurityTypeMetaAttribute(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 *SecurityTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityTypeId() SBE_NOEXCEPT { - return 167; - } + 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 static SBE_CONSTEXPR std::uint64_t securityTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityTypeSinceVersion(); + return m_actingVersion >= securityTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityTypeEncodingOffset() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityTypeEncodingOffset() SBE_NOEXCEPT + { + return 59; + } - static SBE_CONSTEXPR char securityTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + 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::size_t securityTypeEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t securityTypeLength() 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 + 59; - } + SBE_NODISCARD const char *securityType() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 59; + } - SBE_NODISCARD char *securityType() SBE_NOEXCEPT { - return m_buffer + m_offset + 59; - } + SBE_NODISCARD char *securityType() SBE_NOEXCEPT + { + return m_buffer + m_offset + 59; + } - SBE_NODISCARD char securityType(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for securityType [E104]"); - } + 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 + 59 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 59 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture54 & - securityType(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for securityType [E105]"); - } + MDInstrumentDefinitionFuture54 &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 + 59 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 59 + (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::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 + 59, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 59, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionFuture54 & - putSecurityType(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 59, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionFuture54 &putSecurityType(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 59, src, sizeof(char) * 6); + return *this; + } - std::string getSecurityTypeAsString() const { - const char *buffer = m_buffer + m_offset + 59; - size_t length = 0; + SBE_NODISCARD std::string getSecurityTypeAsString() const + { + const char *buffer = m_buffer + m_offset + 59; + 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 getSecurityTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityTypeAsString(); + std::string getSecurityTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityTypeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityTypeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 59; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityTypeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 59; + 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 - MDInstrumentDefinitionFuture54 &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]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionFuture54 &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 + 59, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 59 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 59, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 59 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionFuture54 &putSecurityType(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityType [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionFuture54 &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 + 59, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 59 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 59, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 59 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - CFICodeMetaAttribute(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 *CFICodeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t cFICodeId() SBE_NOEXCEPT { return 461; } + static SBE_CONSTEXPR std::uint16_t cFICodeId() SBE_NOEXCEPT + { + return 461; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cFICodeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cFICodeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool cFICodeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool cFICodeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= cFICodeSinceVersion(); + return m_actingVersion >= cFICodeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cFICodeEncodingOffset() SBE_NOEXCEPT { - return 65; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cFICodeEncodingOffset() SBE_NOEXCEPT + { + return 65; + } - static SBE_CONSTEXPR char cFICodeNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char cFICodeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char cFICodeMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char cFICodeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char cFICodeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char cFICodeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t cFICodeEncodingLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::size_t cFICodeEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t cFICodeLength() SBE_NOEXCEPT { return 6; } + static SBE_CONSTEXPR std::uint64_t cFICodeLength() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD const char *cFICode() const SBE_NOEXCEPT { - return m_buffer + m_offset + 65; - } + SBE_NODISCARD const char *cFICode() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 65; + } - SBE_NODISCARD char *cFICode() SBE_NOEXCEPT { - return m_buffer + m_offset + 65; - } + SBE_NODISCARD char *cFICode() SBE_NOEXCEPT + { + return m_buffer + m_offset + 65; + } - SBE_NODISCARD char cFICode(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for cFICode [E104]"); - } + SBE_NODISCARD char cFICode(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for cFICode [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); + } - MDInstrumentDefinitionFuture54 & - cFICode(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for cFICode [E105]"); - } + MDInstrumentDefinitionFuture54 &cFICode(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for cFICode [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 getCFICode(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error("length too large for getCFICode [E106]"); - } + std::uint64_t getCFICode(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getCFICode [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; + } - MDInstrumentDefinitionFuture54 & - putCFICode(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 65, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionFuture54 &putCFICode(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 65, src, sizeof(char) * 6); + return *this; + } - std::string getCFICodeAsString() const { - const char *buffer = m_buffer + m_offset + 65; - size_t length = 0; + SBE_NODISCARD std::string getCFICodeAsString() const + { + const char *buffer = m_buffer + m_offset + 65; + 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 getCFICodeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCFICodeAsString(); + std::string getCFICodeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCFICodeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getCFICodeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 65; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCFICodeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 65; + 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 - MDInstrumentDefinitionFuture54 &putCFICode(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putCFICode [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionFuture54 &putCFICode(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putCFICode [E106]"); + } - std::memcpy(m_buffer + m_offset + 65, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 65 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 65, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 65 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionFuture54 &putCFICode(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putCFICode [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionFuture54 &putCFICode(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putCFICode [E106]"); + } - std::memcpy(m_buffer + m_offset + 65, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 65 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 65, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 65 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - 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 ""; - } - } + 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; - } + 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 static SBE_CONSTEXPR std::uint64_t maturityMonthYearSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool maturityMonthYearInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool maturityMonthYearInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= maturityMonthYearSinceVersion(); + return m_actingVersion >= maturityMonthYearSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maturityMonthYearEncodingOffset() SBE_NOEXCEPT { - return 71; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maturityMonthYearEncodingOffset() SBE_NOEXCEPT + { + return 71; + } - private: - MaturityMonthYear m_maturityMonthYear; +private: + MaturityMonthYear m_maturityMonthYear; - public: - SBE_NODISCARD MaturityMonthYear &maturityMonthYear() { - m_maturityMonthYear.wrap( - m_buffer, m_offset + 71, m_actingVersion, m_bufferLength); - return m_maturityMonthYear; - } +public: + SBE_NODISCARD MaturityMonthYear &maturityMonthYear() + { + m_maturityMonthYear.wrap(m_buffer, m_offset + 71, m_actingVersion, m_bufferLength); + return m_maturityMonthYear; + } - SBE_NODISCARD static const char * - CurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Currency"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Currency"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t currencyId() SBE_NOEXCEPT { return 15; } + 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 static SBE_CONSTEXPR std::uint64_t currencySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool currencyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool currencyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= currencySinceVersion(); + return m_actingVersion >= currencySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - currencyEncodingOffset() SBE_NOEXCEPT { - return 76; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t currencyEncodingOffset() SBE_NOEXCEPT + { + return 76; + } - static SBE_CONSTEXPR char currencyNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char currencyNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char currencyMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char currencyMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char currencyMaxValue() SBE_NOEXCEPT { - return (char)126; - } + 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::size_t currencyEncodingLength() SBE_NOEXCEPT + { + return 3; + } - static SBE_CONSTEXPR std::uint64_t currencyLength() 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 + 76; - } + SBE_NODISCARD const char *currency() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 76; + } - SBE_NODISCARD char *currency() SBE_NOEXCEPT { - return m_buffer + m_offset + 76; - } + SBE_NODISCARD char *currency() SBE_NOEXCEPT + { + return m_buffer + m_offset + 76; + } - SBE_NODISCARD char currency(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error("index out of range for currency [E104]"); - } + 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 + 76 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 76 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture54 & - currency(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error("index out of range for currency [E105]"); - } + MDInstrumentDefinitionFuture54 ¤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 + 76 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 76 + (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::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 + 76, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 76, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionFuture54 & - putCurrency(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 76, src, sizeof(char) * 3); - return *this; - } + MDInstrumentDefinitionFuture54 &putCurrency(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 76, src, sizeof(char) * 3); + return *this; + } - MDInstrumentDefinitionFuture54 &putCurrency( - const char value0, const char value1, const char value2) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 76, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 77, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 78, &val2, sizeof(char)); + MDInstrumentDefinitionFuture54 &putCurrency( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 76, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 77, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 78, &val2, sizeof(char)); - return *this; - } + return *this; + } - std::string getCurrencyAsString() const { - const char *buffer = m_buffer + m_offset + 76; - size_t length = 0; + SBE_NODISCARD std::string getCurrencyAsString() const + { + const char *buffer = m_buffer + m_offset + 76; + 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 getCurrencyAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCurrencyAsString(); + std::string getCurrencyAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCurrencyAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getCurrencyAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 76; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCurrencyAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 76; + 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 - MDInstrumentDefinitionFuture54 &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]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionFuture54 &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 + 76, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 76 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 76, str.data(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 76 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionFuture54 &putCurrency(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error("string too large for putCurrency [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionFuture54 &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 + 76, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 76 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 76, str.c_str(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 76 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SettlCurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Currency"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SettlCurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Currency"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t settlCurrencyId() SBE_NOEXCEPT { - return 120; - } + static SBE_CONSTEXPR std::uint16_t settlCurrencyId() SBE_NOEXCEPT + { + return 120; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - settlCurrencySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t settlCurrencySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool settlCurrencyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool settlCurrencyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= settlCurrencySinceVersion(); + return m_actingVersion >= settlCurrencySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - settlCurrencyEncodingOffset() SBE_NOEXCEPT { - return 79; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t settlCurrencyEncodingOffset() SBE_NOEXCEPT + { + return 79; + } - static SBE_CONSTEXPR char settlCurrencyNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char settlCurrencyNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char settlCurrencyMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char settlCurrencyMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char settlCurrencyMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char settlCurrencyMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t settlCurrencyEncodingLength() SBE_NOEXCEPT { - return 3; - } + static SBE_CONSTEXPR std::size_t settlCurrencyEncodingLength() SBE_NOEXCEPT + { + return 3; + } - static SBE_CONSTEXPR std::uint64_t settlCurrencyLength() SBE_NOEXCEPT { - return 3; - } + static SBE_CONSTEXPR std::uint64_t settlCurrencyLength() SBE_NOEXCEPT + { + return 3; + } - SBE_NODISCARD const char *settlCurrency() const SBE_NOEXCEPT { - return m_buffer + m_offset + 79; - } + SBE_NODISCARD const char *settlCurrency() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 79; + } - SBE_NODISCARD char *settlCurrency() SBE_NOEXCEPT { - return m_buffer + m_offset + 79; - } + SBE_NODISCARD char *settlCurrency() SBE_NOEXCEPT + { + return m_buffer + m_offset + 79; + } - SBE_NODISCARD char settlCurrency(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error( - "index out of range for settlCurrency [E104]"); - } + SBE_NODISCARD char settlCurrency(const std::uint64_t index) const + { + if (index >= 3) + { + throw std::runtime_error("index out of range for settlCurrency [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 79 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 79 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture54 & - settlCurrency(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error( - "index out of range for settlCurrency [E105]"); - } + MDInstrumentDefinitionFuture54 &settlCurrency(const std::uint64_t index, const char value) + { + if (index >= 3) + { + throw std::runtime_error("index out of range for settlCurrency [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 79 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 79 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSettlCurrency(char *const dst, const std::uint64_t length) const { - if (length > 3) { - throw std::runtime_error( - "length too large for getSettlCurrency [E106]"); - } + std::uint64_t getSettlCurrency(char *const dst, const std::uint64_t length) const + { + if (length > 3) + { + throw std::runtime_error("length too large for getSettlCurrency [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 79, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 79, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionFuture54 & - putSettlCurrency(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 79, src, sizeof(char) * 3); - return *this; - } + MDInstrumentDefinitionFuture54 &putSettlCurrency(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 79, src, sizeof(char) * 3); + return *this; + } - MDInstrumentDefinitionFuture54 &putSettlCurrency( - const char value0, const char value1, const char value2) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 79, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 80, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 81, &val2, sizeof(char)); + MDInstrumentDefinitionFuture54 &putSettlCurrency( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 79, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 80, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 81, &val2, sizeof(char)); - return *this; - } + return *this; + } - std::string getSettlCurrencyAsString() const { - const char *buffer = m_buffer + m_offset + 79; - size_t length = 0; + SBE_NODISCARD std::string getSettlCurrencyAsString() const + { + const char *buffer = m_buffer + m_offset + 79; + 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 getSettlCurrencyAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSettlCurrencyAsString(); + std::string getSettlCurrencyAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSettlCurrencyAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSettlCurrencyAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 79; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSettlCurrencyAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 79; + 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 - MDInstrumentDefinitionFuture54 & - putSettlCurrency(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putSettlCurrency [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionFuture54 &putSettlCurrency(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putSettlCurrency [E106]"); + } - std::memcpy(m_buffer + m_offset + 79, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 79 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 79, str.data(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 79 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionFuture54 &putSettlCurrency(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putSettlCurrency [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionFuture54 &putSettlCurrency(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putSettlCurrency [E106]"); + } - std::memcpy(m_buffer + m_offset + 79, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 79 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 79, str.c_str(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 79 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - MatchAlgorithmMetaAttribute(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 *MatchAlgorithmMetaAttribute(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 matchAlgorithmId() SBE_NOEXCEPT { - return 1142; - } + static SBE_CONSTEXPR std::uint16_t matchAlgorithmId() SBE_NOEXCEPT + { + return 1142; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchAlgorithmSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchAlgorithmSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchAlgorithmInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchAlgorithmInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchAlgorithmSinceVersion(); + return m_actingVersion >= matchAlgorithmSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchAlgorithmEncodingOffset() SBE_NOEXCEPT { - return 82; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchAlgorithmEncodingOffset() SBE_NOEXCEPT + { + return 82; + } - static SBE_CONSTEXPR char matchAlgorithmNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char matchAlgorithmNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char matchAlgorithmMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char matchAlgorithmMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char matchAlgorithmMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char matchAlgorithmMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - matchAlgorithmEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchAlgorithmEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD char matchAlgorithm() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 82, sizeof(char)); - return (val); - } + SBE_NODISCARD char matchAlgorithm() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 82, sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture54 & - matchAlgorithm(const char value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 82, &val, sizeof(char)); - return *this; - } + MDInstrumentDefinitionFuture54 &matchAlgorithm(const char value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 82, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char * - MinTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MinTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t minTradeVolId() SBE_NOEXCEPT { - return 562; - } + static SBE_CONSTEXPR std::uint16_t minTradeVolId() SBE_NOEXCEPT + { + return 562; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minTradeVolSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minTradeVolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minTradeVolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minTradeVolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minTradeVolSinceVersion(); + return m_actingVersion >= minTradeVolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minTradeVolEncodingOffset() SBE_NOEXCEPT { - return 83; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minTradeVolEncodingOffset() SBE_NOEXCEPT + { + return 83; + } - static SBE_CONSTEXPR std::uint32_t minTradeVolNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t minTradeVolNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t minTradeVolMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t minTradeVolMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t minTradeVolMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t minTradeVolMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t minTradeVolEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t minTradeVolEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t minTradeVol() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 83, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t minTradeVol() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 83, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionFuture54 & - minTradeVol(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 83, &val, sizeof(std::uint32_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &minTradeVol(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 83, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - MaxTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MaxTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t maxTradeVolId() SBE_NOEXCEPT { - return 1140; - } + static SBE_CONSTEXPR std::uint16_t maxTradeVolId() SBE_NOEXCEPT + { + return 1140; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - maxTradeVolSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maxTradeVolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool maxTradeVolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool maxTradeVolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= maxTradeVolSinceVersion(); + return m_actingVersion >= maxTradeVolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maxTradeVolEncodingOffset() SBE_NOEXCEPT { - return 87; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maxTradeVolEncodingOffset() SBE_NOEXCEPT + { + return 87; + } - static SBE_CONSTEXPR std::uint32_t maxTradeVolNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t maxTradeVolNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t maxTradeVolMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t maxTradeVolMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t maxTradeVolMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t maxTradeVolMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t maxTradeVolEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t maxTradeVolEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t maxTradeVol() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 87, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t maxTradeVol() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 87, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionFuture54 & - maxTradeVol(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 87, &val, sizeof(std::uint32_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &maxTradeVol(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 87, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char *MinPriceIncrementMetaAttribute( - 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 *MinPriceIncrementMetaAttribute(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 minPriceIncrementId() SBE_NOEXCEPT { - return 969; - } + static SBE_CONSTEXPR std::uint16_t minPriceIncrementId() SBE_NOEXCEPT + { + return 969; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minPriceIncrementSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minPriceIncrementSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool minPriceIncrementInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minPriceIncrementInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minPriceIncrementSinceVersion(); + return m_actingVersion >= minPriceIncrementSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minPriceIncrementEncodingOffset() SBE_NOEXCEPT { - return 91; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minPriceIncrementEncodingOffset() SBE_NOEXCEPT + { + return 91; + } - private: - PRICE9 m_minPriceIncrement; +private: + PRICE9 m_minPriceIncrement; - public: - SBE_NODISCARD PRICE9 &minPriceIncrement() { - m_minPriceIncrement.wrap( - m_buffer, m_offset + 91, m_actingVersion, m_bufferLength); - return m_minPriceIncrement; - } +public: + SBE_NODISCARD PRICE9 &minPriceIncrement() + { + m_minPriceIncrement.wrap(m_buffer, m_offset + 91, m_actingVersion, m_bufferLength); + return m_minPriceIncrement; + } - SBE_NODISCARD static const char * - DisplayFactorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "float"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DisplayFactorMetaAttribute(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 displayFactorId() SBE_NOEXCEPT { - return 9787; - } + static SBE_CONSTEXPR std::uint16_t displayFactorId() SBE_NOEXCEPT + { + return 9787; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - displayFactorSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t displayFactorSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool displayFactorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool displayFactorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= displayFactorSinceVersion(); + return m_actingVersion >= displayFactorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - displayFactorEncodingOffset() SBE_NOEXCEPT { - return 99; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t displayFactorEncodingOffset() SBE_NOEXCEPT + { + return 99; + } - private: - Decimal9 m_displayFactor; +private: + Decimal9 m_displayFactor; - public: - SBE_NODISCARD Decimal9 &displayFactor() { - m_displayFactor.wrap( - m_buffer, m_offset + 99, m_actingVersion, m_bufferLength); - return m_displayFactor; - } +public: + SBE_NODISCARD Decimal9 &displayFactor() + { + m_displayFactor.wrap(m_buffer, m_offset + 99, m_actingVersion, m_bufferLength); + return m_displayFactor; + } - SBE_NODISCARD static const char * - MainFractionMetaAttribute(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 *MainFractionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mainFractionId() SBE_NOEXCEPT { - return 37702; - } + static SBE_CONSTEXPR std::uint16_t mainFractionId() SBE_NOEXCEPT + { + return 37702; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mainFractionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mainFractionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mainFractionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mainFractionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mainFractionSinceVersion(); + return m_actingVersion >= mainFractionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mainFractionEncodingOffset() SBE_NOEXCEPT { - return 107; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mainFractionEncodingOffset() SBE_NOEXCEPT + { + return 107; + } - static SBE_CONSTEXPR std::uint8_t mainFractionNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t mainFractionNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t mainFractionMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t mainFractionMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t mainFractionMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t mainFractionMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t mainFractionEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t mainFractionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t mainFraction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 107, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t mainFraction() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 107, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionFuture54 & - mainFraction(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 107, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &mainFraction(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 107, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - SubFractionMetaAttribute(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 *SubFractionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t subFractionId() SBE_NOEXCEPT { - return 37703; - } + static SBE_CONSTEXPR std::uint16_t subFractionId() SBE_NOEXCEPT + { + return 37703; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - subFractionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t subFractionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool subFractionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool subFractionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= subFractionSinceVersion(); + return m_actingVersion >= subFractionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - subFractionEncodingOffset() SBE_NOEXCEPT { - return 108; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t subFractionEncodingOffset() SBE_NOEXCEPT + { + return 108; + } - static SBE_CONSTEXPR std::uint8_t subFractionNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t subFractionNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t subFractionMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t subFractionMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t subFractionMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t subFractionMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t subFractionEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t subFractionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t subFraction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 108, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t subFraction() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 108, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionFuture54 & - subFraction(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 108, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &subFraction(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 108, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char *PriceDisplayFormatMetaAttribute( - 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 *PriceDisplayFormatMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t priceDisplayFormatId() SBE_NOEXCEPT { - return 9800; - } + static SBE_CONSTEXPR std::uint16_t priceDisplayFormatId() SBE_NOEXCEPT + { + return 9800; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceDisplayFormatSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceDisplayFormatSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool priceDisplayFormatInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool priceDisplayFormatInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= priceDisplayFormatSinceVersion(); + return m_actingVersion >= priceDisplayFormatSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceDisplayFormatEncodingOffset() SBE_NOEXCEPT { - return 109; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceDisplayFormatEncodingOffset() SBE_NOEXCEPT + { + return 109; + } - static SBE_CONSTEXPR std::uint8_t - priceDisplayFormatNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t priceDisplayFormatNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - priceDisplayFormatEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t priceDisplayFormatEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t priceDisplayFormat() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 109, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t priceDisplayFormat() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 109, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionFuture54 & - priceDisplayFormat(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 109, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &priceDisplayFormat(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 109, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - UnitOfMeasureMetaAttribute(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 *UnitOfMeasureMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t unitOfMeasureId() SBE_NOEXCEPT { - return 996; - } + static SBE_CONSTEXPR std::uint16_t unitOfMeasureId() SBE_NOEXCEPT + { + return 996; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - unitOfMeasureSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t unitOfMeasureSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool unitOfMeasureInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool unitOfMeasureInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= unitOfMeasureSinceVersion(); + return m_actingVersion >= unitOfMeasureSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - unitOfMeasureEncodingOffset() SBE_NOEXCEPT { - return 110; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t unitOfMeasureEncodingOffset() SBE_NOEXCEPT + { + return 110; + } - static SBE_CONSTEXPR char unitOfMeasureNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char unitOfMeasureNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char unitOfMeasureMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char unitOfMeasureMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char unitOfMeasureMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char unitOfMeasureMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t unitOfMeasureEncodingLength() SBE_NOEXCEPT { - return 30; - } + static SBE_CONSTEXPR std::size_t unitOfMeasureEncodingLength() SBE_NOEXCEPT + { + return 30; + } - static SBE_CONSTEXPR std::uint64_t unitOfMeasureLength() SBE_NOEXCEPT { - return 30; - } + static SBE_CONSTEXPR std::uint64_t unitOfMeasureLength() SBE_NOEXCEPT + { + return 30; + } - SBE_NODISCARD const char *unitOfMeasure() const SBE_NOEXCEPT { - return m_buffer + m_offset + 110; - } + SBE_NODISCARD const char *unitOfMeasure() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 110; + } - SBE_NODISCARD char *unitOfMeasure() SBE_NOEXCEPT { - return m_buffer + m_offset + 110; - } + SBE_NODISCARD char *unitOfMeasure() SBE_NOEXCEPT + { + return m_buffer + m_offset + 110; + } - SBE_NODISCARD char unitOfMeasure(const std::uint64_t index) const { - if (index >= 30) { - throw std::runtime_error( - "index out of range for unitOfMeasure [E104]"); - } + SBE_NODISCARD char unitOfMeasure(const std::uint64_t index) const + { + if (index >= 30) + { + throw std::runtime_error("index out of range for unitOfMeasure [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 110 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 110 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture54 & - unitOfMeasure(const std::uint64_t index, const char value) { - if (index >= 30) { - throw std::runtime_error( - "index out of range for unitOfMeasure [E105]"); - } + MDInstrumentDefinitionFuture54 &unitOfMeasure(const std::uint64_t index, const char value) + { + if (index >= 30) + { + throw std::runtime_error("index out of range for unitOfMeasure [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 110 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 110 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getUnitOfMeasure(char *const dst, const std::uint64_t length) const { - if (length > 30) { - throw std::runtime_error( - "length too large for getUnitOfMeasure [E106]"); - } + std::uint64_t getUnitOfMeasure(char *const dst, const std::uint64_t length) const + { + if (length > 30) + { + throw std::runtime_error("length too large for getUnitOfMeasure [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 110, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 110, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionFuture54 & - putUnitOfMeasure(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 110, src, sizeof(char) * 30); - return *this; - } + MDInstrumentDefinitionFuture54 &putUnitOfMeasure(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 110, src, sizeof(char) * 30); + return *this; + } - std::string getUnitOfMeasureAsString() const { - const char *buffer = m_buffer + m_offset + 110; - size_t length = 0; + SBE_NODISCARD std::string getUnitOfMeasureAsString() const + { + const char *buffer = m_buffer + m_offset + 110; + 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 getUnitOfMeasureAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getUnitOfMeasureAsString(); + std::string getUnitOfMeasureAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getUnitOfMeasureAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getUnitOfMeasureAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 110; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getUnitOfMeasureAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 110; + 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 - MDInstrumentDefinitionFuture54 & - putUnitOfMeasure(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 30) { - throw std::runtime_error( - "string too large for putUnitOfMeasure [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionFuture54 &putUnitOfMeasure(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 30) + { + throw std::runtime_error("string too large for putUnitOfMeasure [E106]"); + } - std::memcpy(m_buffer + m_offset + 110, str.data(), srcLength); - for (size_t start = srcLength; start < 30; ++start) { - m_buffer[m_offset + 110 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 110, str.data(), srcLength); + for (size_t start = srcLength; start < 30; ++start) + { + m_buffer[m_offset + 110 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionFuture54 &putUnitOfMeasure(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 30) { - throw std::runtime_error( - "string too large for putUnitOfMeasure [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionFuture54 &putUnitOfMeasure(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 30) + { + throw std::runtime_error("string too large for putUnitOfMeasure [E106]"); + } - std::memcpy(m_buffer + m_offset + 110, str.c_str(), srcLength); - for (size_t start = srcLength; start < 30; ++start) { - m_buffer[m_offset + 110 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 110, str.c_str(), srcLength); + for (size_t start = srcLength; start < 30; ++start) + { + m_buffer[m_offset + 110 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *UnitOfMeasureQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UnitOfMeasureQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t unitOfMeasureQtyId() SBE_NOEXCEPT { - return 1147; - } + static SBE_CONSTEXPR std::uint16_t unitOfMeasureQtyId() SBE_NOEXCEPT + { + return 1147; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - unitOfMeasureQtySinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t unitOfMeasureQtySinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool unitOfMeasureQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool unitOfMeasureQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= unitOfMeasureQtySinceVersion(); + return m_actingVersion >= unitOfMeasureQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - unitOfMeasureQtyEncodingOffset() SBE_NOEXCEPT { - return 140; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t unitOfMeasureQtyEncodingOffset() SBE_NOEXCEPT + { + return 140; + } - private: - Decimal9NULL m_unitOfMeasureQty; +private: + Decimal9NULL m_unitOfMeasureQty; - public: - SBE_NODISCARD Decimal9NULL &unitOfMeasureQty() { - m_unitOfMeasureQty.wrap( - m_buffer, m_offset + 140, m_actingVersion, m_bufferLength); - return m_unitOfMeasureQty; - } +public: + SBE_NODISCARD Decimal9NULL &unitOfMeasureQty() + { + m_unitOfMeasureQty.wrap(m_buffer, m_offset + 140, m_actingVersion, m_bufferLength); + return m_unitOfMeasureQty; + } - SBE_NODISCARD static const char *TradingReferencePriceMetaAttribute( - 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 *TradingReferencePriceMetaAttribute(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 tradingReferencePriceId() SBE_NOEXCEPT { - return 1150; - } + static SBE_CONSTEXPR std::uint16_t tradingReferencePriceId() SBE_NOEXCEPT + { + return 1150; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingReferencePriceSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingReferencePriceSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool tradingReferencePriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tradingReferencePriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tradingReferencePriceSinceVersion(); + return m_actingVersion >= tradingReferencePriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingReferencePriceEncodingOffset() SBE_NOEXCEPT { - return 148; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingReferencePriceEncodingOffset() SBE_NOEXCEPT + { + return 148; + } - private: - PRICENULL9 m_tradingReferencePrice; +private: + PRICENULL9 m_tradingReferencePrice; - public: - SBE_NODISCARD PRICENULL9 &tradingReferencePrice() { - m_tradingReferencePrice.wrap( - m_buffer, m_offset + 148, m_actingVersion, m_bufferLength); - return m_tradingReferencePrice; - } +public: + SBE_NODISCARD PRICENULL9 &tradingReferencePrice() + { + m_tradingReferencePrice.wrap(m_buffer, m_offset + 148, m_actingVersion, m_bufferLength); + return m_tradingReferencePrice; + } - SBE_NODISCARD static const char * - SettlPriceTypeMetaAttribute(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 *SettlPriceTypeMetaAttribute(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 settlPriceTypeId() SBE_NOEXCEPT { - return 731; - } + static SBE_CONSTEXPR std::uint16_t settlPriceTypeId() SBE_NOEXCEPT + { + return 731; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - settlPriceTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t settlPriceTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= settlPriceTypeSinceVersion(); + return m_actingVersion >= settlPriceTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingOffset() SBE_NOEXCEPT { - return 156; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingOffset() SBE_NOEXCEPT + { + return 156; + } - private: - SettlPriceType m_settlPriceType; +private: + SettlPriceType m_settlPriceType; - public: - SBE_NODISCARD SettlPriceType &settlPriceType() { - m_settlPriceType.wrap( - m_buffer, m_offset + 156, m_actingVersion, m_bufferLength); - return m_settlPriceType; - } +public: + SBE_NODISCARD SettlPriceType &settlPriceType() + { + m_settlPriceType.wrap(m_buffer, m_offset + 156, m_actingVersion, m_bufferLength); + return m_settlPriceType; + } - static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char *OpenInterestQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OpenInterestQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t openInterestQtyId() SBE_NOEXCEPT { - return 5792; - } + static SBE_CONSTEXPR std::uint16_t openInterestQtyId() SBE_NOEXCEPT + { + return 5792; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - openInterestQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t openInterestQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool openInterestQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool openInterestQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= openInterestQtySinceVersion(); + return m_actingVersion >= openInterestQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - openInterestQtyEncodingOffset() SBE_NOEXCEPT { - return 157; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t openInterestQtyEncodingOffset() SBE_NOEXCEPT + { + return 157; + } - static SBE_CONSTEXPR std::int32_t openInterestQtyNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t openInterestQtyNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t openInterestQtyMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t openInterestQtyMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t openInterestQtyMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t openInterestQtyMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t - openInterestQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t openInterestQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t openInterestQty() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 157, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t openInterestQty() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 157, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionFuture54 & - openInterestQty(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 157, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &openInterestQty(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 157, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - ClearedVolumeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ClearedVolumeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t clearedVolumeId() SBE_NOEXCEPT { - return 5791; - } + static SBE_CONSTEXPR std::uint16_t clearedVolumeId() SBE_NOEXCEPT + { + return 5791; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clearedVolumeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clearedVolumeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool clearedVolumeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool clearedVolumeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clearedVolumeSinceVersion(); + return m_actingVersion >= clearedVolumeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clearedVolumeEncodingOffset() SBE_NOEXCEPT { - return 161; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clearedVolumeEncodingOffset() SBE_NOEXCEPT + { + return 161; + } - static SBE_CONSTEXPR std::int32_t clearedVolumeNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t clearedVolumeNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t clearedVolumeMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t clearedVolumeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t clearedVolumeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t clearedVolumeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t clearedVolumeEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t clearedVolumeEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t clearedVolume() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 161, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t clearedVolume() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 161, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionFuture54 & - clearedVolume(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 161, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &clearedVolume(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 161, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - HighLimitPriceMetaAttribute(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 *HighLimitPriceMetaAttribute(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 highLimitPriceId() SBE_NOEXCEPT { - return 1149; - } + static SBE_CONSTEXPR std::uint16_t highLimitPriceId() SBE_NOEXCEPT + { + return 1149; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - highLimitPriceSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t highLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= highLimitPriceSinceVersion(); + return m_actingVersion >= highLimitPriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - highLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 165; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t highLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 165; + } - private: - PRICENULL9 m_highLimitPrice; +private: + PRICENULL9 m_highLimitPrice; - public: - SBE_NODISCARD PRICENULL9 &highLimitPrice() { - m_highLimitPrice.wrap( - m_buffer, m_offset + 165, m_actingVersion, m_bufferLength); - return m_highLimitPrice; - } +public: + SBE_NODISCARD PRICENULL9 &highLimitPrice() + { + m_highLimitPrice.wrap(m_buffer, m_offset + 165, m_actingVersion, m_bufferLength); + return m_highLimitPrice; + } - SBE_NODISCARD static const char * - LowLimitPriceMetaAttribute(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 *LowLimitPriceMetaAttribute(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 lowLimitPriceId() SBE_NOEXCEPT { - return 1148; - } + static SBE_CONSTEXPR std::uint16_t lowLimitPriceId() SBE_NOEXCEPT + { + return 1148; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lowLimitPriceSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lowLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lowLimitPriceSinceVersion(); + return m_actingVersion >= lowLimitPriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lowLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 173; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lowLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 173; + } - private: - PRICENULL9 m_lowLimitPrice; +private: + PRICENULL9 m_lowLimitPrice; - public: - SBE_NODISCARD PRICENULL9 &lowLimitPrice() { - m_lowLimitPrice.wrap( - m_buffer, m_offset + 173, m_actingVersion, m_bufferLength); - return m_lowLimitPrice; - } +public: + SBE_NODISCARD PRICENULL9 &lowLimitPrice() + { + m_lowLimitPrice.wrap(m_buffer, m_offset + 173, m_actingVersion, m_bufferLength); + return m_lowLimitPrice; + } - SBE_NODISCARD static const char *MaxPriceVariationMetaAttribute( - 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 *MaxPriceVariationMetaAttribute(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 maxPriceVariationId() SBE_NOEXCEPT { - return 1143; - } + static SBE_CONSTEXPR std::uint16_t maxPriceVariationId() SBE_NOEXCEPT + { + return 1143; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - maxPriceVariationSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maxPriceVariationSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool maxPriceVariationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool maxPriceVariationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= maxPriceVariationSinceVersion(); + return m_actingVersion >= maxPriceVariationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maxPriceVariationEncodingOffset() SBE_NOEXCEPT { - return 181; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maxPriceVariationEncodingOffset() SBE_NOEXCEPT + { + return 181; + } - private: - PRICENULL9 m_maxPriceVariation; +private: + PRICENULL9 m_maxPriceVariation; - public: - SBE_NODISCARD PRICENULL9 &maxPriceVariation() { - m_maxPriceVariation.wrap( - m_buffer, m_offset + 181, m_actingVersion, m_bufferLength); - return m_maxPriceVariation; - } +public: + SBE_NODISCARD PRICENULL9 &maxPriceVariation() + { + m_maxPriceVariation.wrap(m_buffer, m_offset + 181, m_actingVersion, m_bufferLength); + return m_maxPriceVariation; + } - SBE_NODISCARD static const char * - DecayQuantityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DecayQuantityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t decayQuantityId() SBE_NOEXCEPT { - return 5818; - } + static SBE_CONSTEXPR std::uint16_t decayQuantityId() SBE_NOEXCEPT + { + return 5818; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - decayQuantitySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t decayQuantitySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool decayQuantityInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool decayQuantityInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= decayQuantitySinceVersion(); + return m_actingVersion >= decayQuantitySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - decayQuantityEncodingOffset() SBE_NOEXCEPT { - return 189; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t decayQuantityEncodingOffset() SBE_NOEXCEPT + { + return 189; + } - static SBE_CONSTEXPR std::int32_t decayQuantityNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t decayQuantityNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t decayQuantityMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t decayQuantityMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t decayQuantityMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t decayQuantityMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t decayQuantityEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t decayQuantityEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t decayQuantity() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 189, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t decayQuantity() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 189, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionFuture54 & - decayQuantity(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 189, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &decayQuantity(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 189, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - DecayStartDateMetaAttribute(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 *DecayStartDateMetaAttribute(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 decayStartDateId() SBE_NOEXCEPT { - return 5819; - } + static SBE_CONSTEXPR std::uint16_t decayStartDateId() SBE_NOEXCEPT + { + return 5819; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - decayStartDateSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t decayStartDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool decayStartDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool decayStartDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= decayStartDateSinceVersion(); + return m_actingVersion >= decayStartDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - decayStartDateEncodingOffset() SBE_NOEXCEPT { - return 193; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t decayStartDateEncodingOffset() SBE_NOEXCEPT + { + return 193; + } - static SBE_CONSTEXPR std::uint16_t decayStartDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t decayStartDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t decayStartDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t decayStartDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t decayStartDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t decayStartDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t - decayStartDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t decayStartDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t decayStartDate() 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 decayStartDate() 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); + } - MDInstrumentDefinitionFuture54 & - decayStartDate(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; - } + MDInstrumentDefinitionFuture54 &decayStartDate(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 *OriginalContractSizeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OriginalContractSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t originalContractSizeId() SBE_NOEXCEPT { - return 5849; - } + static SBE_CONSTEXPR std::uint16_t originalContractSizeId() SBE_NOEXCEPT + { + return 5849; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - originalContractSizeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t originalContractSizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool originalContractSizeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool originalContractSizeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= originalContractSizeSinceVersion(); + return m_actingVersion >= originalContractSizeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - originalContractSizeEncodingOffset() SBE_NOEXCEPT { - return 195; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t originalContractSizeEncodingOffset() SBE_NOEXCEPT + { + return 195; + } - static SBE_CONSTEXPR std::int32_t - originalContractSizeNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t originalContractSizeNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t - originalContractSizeMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t originalContractSizeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t - originalContractSizeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t originalContractSizeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t - originalContractSizeEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t originalContractSizeEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t originalContractSize() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 195, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t originalContractSize() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 195, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionFuture54 & - originalContractSize(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 195, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &originalContractSize(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 195, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char *ContractMultiplierMetaAttribute( - 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 *ContractMultiplierMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t contractMultiplierId() SBE_NOEXCEPT { - return 231; - } + static SBE_CONSTEXPR std::uint16_t contractMultiplierId() SBE_NOEXCEPT + { + return 231; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - contractMultiplierSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t contractMultiplierSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool contractMultiplierInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool contractMultiplierInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= contractMultiplierSinceVersion(); + return m_actingVersion >= contractMultiplierSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - contractMultiplierEncodingOffset() SBE_NOEXCEPT { - return 199; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t contractMultiplierEncodingOffset() SBE_NOEXCEPT + { + return 199; + } - static SBE_CONSTEXPR std::int32_t - contractMultiplierNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t contractMultiplierNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t contractMultiplierMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t contractMultiplierMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t contractMultiplierMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t contractMultiplierMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t - contractMultiplierEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t contractMultiplierEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t contractMultiplier() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 199, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t contractMultiplier() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 199, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionFuture54 & - contractMultiplier(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 199, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &contractMultiplier(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 199, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char *ContractMultiplierUnitMetaAttribute( - 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 *ContractMultiplierUnitMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t contractMultiplierUnitId() SBE_NOEXCEPT { - return 1435; - } + static SBE_CONSTEXPR std::uint16_t contractMultiplierUnitId() SBE_NOEXCEPT + { + return 1435; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - contractMultiplierUnitSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t contractMultiplierUnitSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool contractMultiplierUnitInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool contractMultiplierUnitInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= contractMultiplierUnitSinceVersion(); + return m_actingVersion >= contractMultiplierUnitSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - contractMultiplierUnitEncodingOffset() SBE_NOEXCEPT { - return 203; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t contractMultiplierUnitEncodingOffset() SBE_NOEXCEPT + { + return 203; + } - static SBE_CONSTEXPR std::int8_t - contractMultiplierUnitNullValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t contractMultiplierUnitNullValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::int8_t - contractMultiplierUnitMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } + static SBE_CONSTEXPR std::int8_t contractMultiplierUnitMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } - static SBE_CONSTEXPR std::int8_t - contractMultiplierUnitMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t contractMultiplierUnitMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::size_t - contractMultiplierUnitEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t contractMultiplierUnitEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::int8_t contractMultiplierUnit() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 203, sizeof(std::int8_t)); - return (val); - } + SBE_NODISCARD std::int8_t contractMultiplierUnit() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 203, sizeof(std::int8_t)); + return (val); + } - MDInstrumentDefinitionFuture54 & - contractMultiplierUnit(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 203, &val, sizeof(std::int8_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &contractMultiplierUnit(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 203, &val, sizeof(std::int8_t)); + return *this; + } - SBE_NODISCARD static const char *FlowScheduleTypeMetaAttribute( - 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 *FlowScheduleTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t flowScheduleTypeId() SBE_NOEXCEPT { - return 1439; - } + static SBE_CONSTEXPR std::uint16_t flowScheduleTypeId() SBE_NOEXCEPT + { + return 1439; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - flowScheduleTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t flowScheduleTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool flowScheduleTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool flowScheduleTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= flowScheduleTypeSinceVersion(); + return m_actingVersion >= flowScheduleTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - flowScheduleTypeEncodingOffset() SBE_NOEXCEPT { - return 204; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t flowScheduleTypeEncodingOffset() SBE_NOEXCEPT + { + return 204; + } - static SBE_CONSTEXPR std::int8_t flowScheduleTypeNullValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t flowScheduleTypeNullValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::int8_t flowScheduleTypeMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } + static SBE_CONSTEXPR std::int8_t flowScheduleTypeMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } - static SBE_CONSTEXPR std::int8_t flowScheduleTypeMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t flowScheduleTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::size_t - flowScheduleTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t flowScheduleTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::int8_t flowScheduleType() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 204, sizeof(std::int8_t)); - return (val); - } + SBE_NODISCARD std::int8_t flowScheduleType() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 204, sizeof(std::int8_t)); + return (val); + } - MDInstrumentDefinitionFuture54 & - flowScheduleType(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 204, &val, sizeof(std::int8_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &flowScheduleType(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 204, &val, sizeof(std::int8_t)); + return *this; + } - SBE_NODISCARD static const char *MinPriceIncrementAmountMetaAttribute( - 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 *MinPriceIncrementAmountMetaAttribute(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 minPriceIncrementAmountId() SBE_NOEXCEPT { - return 1146; - } + static SBE_CONSTEXPR std::uint16_t minPriceIncrementAmountId() SBE_NOEXCEPT + { + return 1146; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minPriceIncrementAmountSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minPriceIncrementAmountSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool minPriceIncrementAmountInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minPriceIncrementAmountInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minPriceIncrementAmountSinceVersion(); + return m_actingVersion >= minPriceIncrementAmountSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minPriceIncrementAmountEncodingOffset() SBE_NOEXCEPT { - return 205; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minPriceIncrementAmountEncodingOffset() SBE_NOEXCEPT + { + return 205; + } - private: - PRICENULL9 m_minPriceIncrementAmount; +private: + PRICENULL9 m_minPriceIncrementAmount; - public: - SBE_NODISCARD PRICENULL9 &minPriceIncrementAmount() { - m_minPriceIncrementAmount.wrap( - m_buffer, m_offset + 205, m_actingVersion, m_bufferLength); - return m_minPriceIncrementAmount; - } +public: + SBE_NODISCARD PRICENULL9 &minPriceIncrementAmount() + { + m_minPriceIncrementAmount.wrap(m_buffer, m_offset + 205, m_actingVersion, m_bufferLength); + return m_minPriceIncrementAmount; + } - SBE_NODISCARD static const char *UserDefinedInstrumentMetaAttribute( - 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 *UserDefinedInstrumentMetaAttribute(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 userDefinedInstrumentId() SBE_NOEXCEPT { - return 9779; - } + 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 static SBE_CONSTEXPR std::uint64_t userDefinedInstrumentSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool userDefinedInstrumentInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool userDefinedInstrumentInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= userDefinedInstrumentSinceVersion(); + return m_actingVersion >= userDefinedInstrumentSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - userDefinedInstrumentEncodingOffset() SBE_NOEXCEPT { - return 213; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t userDefinedInstrumentEncodingOffset() SBE_NOEXCEPT + { + return 213; + } - static SBE_CONSTEXPR char userDefinedInstrumentNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char userDefinedInstrumentNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char userDefinedInstrumentMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char userDefinedInstrumentMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char userDefinedInstrumentMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char userDefinedInstrumentMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - userDefinedInstrumentEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t userDefinedInstrumentEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD char userDefinedInstrument() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 213, sizeof(char)); - return (val); - } + SBE_NODISCARD char userDefinedInstrument() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 213, sizeof(char)); + return (val); + } - MDInstrumentDefinitionFuture54 & - userDefinedInstrument(const char value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 213, &val, sizeof(char)); - return *this; - } + MDInstrumentDefinitionFuture54 &userDefinedInstrument(const char value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 213, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char *TradingReferenceDateMetaAttribute( - 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 *TradingReferenceDateMetaAttribute(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 tradingReferenceDateId() SBE_NOEXCEPT { - return 5796; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateId() SBE_NOEXCEPT + { + return 5796; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingReferenceDateSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingReferenceDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tradingReferenceDateSinceVersion(); + return m_actingVersion >= tradingReferenceDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingOffset() SBE_NOEXCEPT { - return 214; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingOffset() SBE_NOEXCEPT + { + return 214; + } - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t tradingReferenceDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 214, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t tradingReferenceDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 214, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - MDInstrumentDefinitionFuture54 & - tradingReferenceDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 214, &val, sizeof(std::uint16_t)); - return *this; - } + MDInstrumentDefinitionFuture54 &tradingReferenceDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 214, &val, sizeof(std::uint16_t)); + return *this; + } - class NoEvents { + class NoEvents + { 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 NoEvents &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(static_cast(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 *EventTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t eventTypeId() SBE_NOEXCEPT + { + return 865; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t eventTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool eventTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= eventTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t eventTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t eventTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD EventType::Value eventType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint8_t)); + return EventType::get((val)); + } + + NoEvents &eventType(const EventType::Value 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 *EventTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t eventTimeId() SBE_NOEXCEPT + { + return 1145; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t eventTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool eventTimeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= eventTimeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t eventTimeEncodingOffset() SBE_NOEXCEPT + { + return 1; + } + + static SBE_CONSTEXPR std::uint64_t eventTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t eventTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t eventTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t eventTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t eventTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoEvents &eventTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint64_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoEvents writer) + { + builder << '{'; + builder << R"("EventType": )"; + builder << '"' << writer.eventType() << '"'; + + builder << ", "; + builder << R"("EventTime": )"; + builder << +writer.eventTime(); + + 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: + NoEvents m_noEvents; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 9; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoEventsId() SBE_NOEXCEPT + { + return 864; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoEvents &noEvents() + { + m_noEvents.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noEvents; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoEvents &noEventsCount(const std::uint8_t count) + { + m_noEvents.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noEvents; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noEventsSinceVersion() 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 NoEvents &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 * - EventTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t eventTypeId() SBE_NOEXCEPT { - return 865; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - eventTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool eventTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noEventsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= eventTypeSinceVersion(); + return m_actingVersion >= noEventsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - eventTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - eventTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD EventType::Value eventType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint8_t)); - return EventType::get((val)); - } - - NoEvents &eventType(const EventType::Value 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 * - EventTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t eventTimeId() SBE_NOEXCEPT { - return 1145; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - eventTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool eventTimeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= eventTimeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - eventTimeEncodingOffset() SBE_NOEXCEPT { - return 1; - } - - static SBE_CONSTEXPR std::uint64_t eventTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t eventTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t eventTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t eventTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t eventTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoEvents &eventTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint64_t)); - return *this; - } - - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoEvents writer) { - builder << '{'; - builder << R"("EventType": )"; - builder << '"' << writer.eventType() << '"'; - - builder << ", "; - builder << R"("EventTime": )"; - builder << +writer.eventTime(); - - builder << '}'; - - return builder; - } - }; - - private: - NoEvents m_noEvents; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoEventsId() SBE_NOEXCEPT { - return 864; - } - - SBE_NODISCARD inline NoEvents &noEvents() { - m_noEvents.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noEvents; - } - - NoEvents &noEventsCount(const std::uint8_t count) { - m_noEvents.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noEvents; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noEventsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noEventsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noEventsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoMDFeedTypes { + class NoMDFeedTypes + { 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)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 { 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 < m_count; - } - - inline NoMDFeedTypes &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 * - MDFeedTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDFeedTypeId() SBE_NOEXCEPT { - return 1022; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDFeedTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDFeedTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDFeedTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDFeedTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR char mDFeedTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char mDFeedTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char mDFeedTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t mDFeedTypeEncodingLength() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t mDFeedTypeLength() SBE_NOEXCEPT { - return 3; - } - - SBE_NODISCARD const char *mDFeedType() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char *mDFeedType() SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char mDFeedType(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error( - "index out of range for mDFeedType [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } - - NoMDFeedTypes &mDFeedType(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error( - "index out of range for mDFeedType [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getMDFeedType(char *const dst, const std::uint64_t length) const { - if (length > 3) { - throw std::runtime_error( - "length too large for getMDFeedType [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } - - NoMDFeedTypes &putMDFeedType(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 3); - return *this; - } - - NoMDFeedTypes & - putMDFeedType(const char value0, const char value1, const char value2) - SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 0, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 1, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 2, &val2, sizeof(char)); - - return *this; - } - - std::string getMDFeedTypeAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 3 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getMDFeedTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getMDFeedTypeAsString(); - - 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; - } + 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(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; + } - return oss.str(); - } + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } -#if __cplusplus >= 201703L - std::string_view getMDFeedTypeAsStringView() 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 4; + } - for (; length < 3 && *(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 - NoMDFeedTypes &putMDFeedType(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putMDFeedType [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 < 3; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - return *this; - } -#else - NoMDFeedTypes &putMDFeedType(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putMDFeedType [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 < 3; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } + inline NoMDFeedTypes &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 * - MarketDepthMetaAttribute(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() SBE_NOEXCEPT + { + 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 marketDepthId() SBE_NOEXCEPT { - return 264; - } + #if __cplusplus < 201103L + template inline void forEach(Func& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - marketDepthSinceVersion() SBE_NOEXCEPT { - return 0; - } + #else + template inline void forEach(Func&& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - SBE_NODISCARD bool marketDepthInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= marketDepthSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + #endif - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - marketDepthEncodingOffset() SBE_NOEXCEPT { - return 3; - } + SBE_NODISCARD static const char *MDFeedTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::int8_t marketDepthNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } + static SBE_CONSTEXPR std::uint16_t mDFeedTypeId() SBE_NOEXCEPT + { + return 1022; + } - static SBE_CONSTEXPR std::int8_t marketDepthMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDFeedTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::int8_t marketDepthMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + SBE_NODISCARD bool mDFeedTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDFeedTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - static SBE_CONSTEXPR std::size_t - marketDepthEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDFeedTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD std::int8_t marketDepth() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 3, sizeof(std::int8_t)); - return (val); - } + static SBE_CONSTEXPR char mDFeedTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - NoMDFeedTypes &marketDepth(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 3, &val, sizeof(std::int8_t)); - return *this; - } + static SBE_CONSTEXPR char mDFeedTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDFeedTypes writer) { - builder << '{'; - builder << R"("MDFeedType": )"; - builder << '"' << writer.getMDFeedTypeAsJsonEscapedString().c_str() - << '"'; + static SBE_CONSTEXPR char mDFeedTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - builder << ", "; - builder << R"("MarketDepth": )"; - builder << +writer.marketDepth(); + static SBE_CONSTEXPR std::size_t mDFeedTypeEncodingLength() SBE_NOEXCEPT + { + return 3; + } - builder << '}'; + static SBE_CONSTEXPR std::uint64_t mDFeedTypeLength() SBE_NOEXCEPT + { + return 3; + } - return builder; - } - }; + SBE_NODISCARD const char *mDFeedType() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - private: - NoMDFeedTypes m_noMDFeedTypes; + SBE_NODISCARD char *mDFeedType() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDFeedTypesId() SBE_NOEXCEPT { - return 1141; - } + SBE_NODISCARD char mDFeedType(const std::uint64_t index) const + { + if (index >= 3) + { + throw std::runtime_error("index out of range for mDFeedType [E104]"); + } - SBE_NODISCARD inline NoMDFeedTypes &noMDFeedTypes() { - m_noMDFeedTypes.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDFeedTypes; - } + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } - NoMDFeedTypes &noMDFeedTypesCount(const std::uint8_t count) { - m_noMDFeedTypes.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDFeedTypes; - } + NoMDFeedTypes &mDFeedType(const std::uint64_t index, const char value) + { + if (index >= 3) + { + throw std::runtime_error("index out of range for mDFeedType [E105]"); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDFeedTypesSinceVersion() SBE_NOEXCEPT { - return 0; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } - SBE_NODISCARD bool noMDFeedTypesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDFeedTypesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + std::uint64_t getMDFeedType(char *const dst, const std::uint64_t length) const + { + if (length > 3) + { + throw std::runtime_error("length too large for getMDFeedType [E106]"); + } - class NoInstAttrib { - 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; + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } - SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + NoMDFeedTypes &putMDFeedType(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 3); + return *this; + } - 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; - } + NoMDFeedTypes &putMDFeedType( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 0, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 1, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 2, &val2, sizeof(char)); - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + return *this; + } + + SBE_NODISCARD std::string getMDFeedTypeAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + size_t length = 0; + + for (; length < 3 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getMDFeedTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getMDFeedTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + 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 getMDFeedTypeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + size_t length = 0; + + for (; length < 3 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoMDFeedTypes &putMDFeedType(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putMDFeedType [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #else + NoMDFeedTypes &putMDFeedType(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putMDFeedType [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *MarketDepthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t marketDepthId() SBE_NOEXCEPT + { + return 264; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t marketDepthSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool marketDepthInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= marketDepthSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t marketDepthEncodingOffset() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::int8_t marketDepthNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t marketDepthMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t marketDepthMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t marketDepthEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::int8_t marketDepth() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 3, sizeof(std::int8_t)); + return (val); + } + + NoMDFeedTypes &marketDepth(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 3, &val, sizeof(std::int8_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDFeedTypes writer) + { + builder << '{'; + builder << R"("MDFeedType": )"; + builder << '"' << + writer.getMDFeedTypeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("MarketDepth": )"; + builder << +writer.marketDepth(); + + 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)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; - } +private: + NoMDFeedTypes m_noMDFeedTypes; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 4; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDFeedTypesId() SBE_NOEXCEPT + { + return 1141; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDFeedTypes &noMDFeedTypes() + { + m_noMDFeedTypes.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDFeedTypes; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDFeedTypes &noMDFeedTypesCount(const std::uint8_t count) + { + m_noMDFeedTypes.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDFeedTypes; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDFeedTypesSinceVersion() 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 NoInstAttrib &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 *InstAttribTypeMetaAttribute( - 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 instAttribTypeId() SBE_NOEXCEPT { - return 871; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - instAttribTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool instAttribTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noMDFeedTypesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= instAttribTypeSinceVersion(); + return m_actingVersion >= noMDFeedTypesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - instAttribTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int8_t instAttribTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t instAttribTypeMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t instAttribTypeMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t - instAttribTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::int8_t - instAttribType() SBE_NOEXCEPT { - return (std::int8_t)24; - } - - SBE_NODISCARD static const char *InstAttribValueMetaAttribute( - 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 instAttribValueId() SBE_NOEXCEPT { - return 872; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - instAttribValueSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool instAttribValueInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= instAttribValueSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - instAttribValueEncodingOffset() SBE_NOEXCEPT { - return 0; - } + } + class NoInstAttrib + { private: - InstAttribValue m_instAttribValue; + 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 InstAttribValue &instAttribValue() { - m_instAttribValue.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_instAttribValue; - } + 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; + } - static SBE_CONSTEXPR std::size_t - instAttribValueEncodingLength() SBE_NOEXCEPT { - return 4; - } + 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(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; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoInstAttrib writer) { - builder << '{'; - builder << R"("InstAttribValue": )"; - builder << writer.instAttribValue(); + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } - builder << '}'; + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 4; + } - return builder; - } - }; + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - private: - NoInstAttrib m_noInstAttrib; + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoInstAttribId() SBE_NOEXCEPT { - return 870; - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - SBE_NODISCARD inline NoInstAttrib &noInstAttrib() { - m_noInstAttrib.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noInstAttrib; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - NoInstAttrib &noInstAttribCount(const std::uint8_t count) { - m_noInstAttrib.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noInstAttrib; - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noInstAttribSinceVersion() SBE_NOEXCEPT { - return 0; - } + inline NoInstAttrib &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 bool noInstAttribInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noInstAttribSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + 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(static_cast(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 *InstAttribTypeMetaAttribute(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 instAttribTypeId() SBE_NOEXCEPT + { + return 871; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t instAttribTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool instAttribTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= instAttribTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t instAttribTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::int8_t instAttribTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t instAttribTypeMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t instAttribTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t instAttribTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::int8_t instAttribType() SBE_NOEXCEPT + { + return static_cast(24); + } + + SBE_NODISCARD static const char *InstAttribValueMetaAttribute(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 instAttribValueId() SBE_NOEXCEPT + { + return 872; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t instAttribValueSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool instAttribValueInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= instAttribValueSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t instAttribValueEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - class NoLotTypeRules { 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; - } + InstAttribValue m_instAttribValue; 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; - } + SBE_NODISCARD InstAttribValue &instAttribValue() + { + m_instAttribValue.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_instAttribValue; + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + static SBE_CONSTEXPR std::size_t instAttribValueEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoInstAttrib writer) + { + builder << '{'; + builder << R"("InstAttribValue": )"; + builder << writer.instAttribValue(); + + 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)5); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 5; - 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: + NoInstAttrib m_noInstAttrib; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 5; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoInstAttribId() SBE_NOEXCEPT + { + return 870; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoInstAttrib &noInstAttrib() + { + m_noInstAttrib.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noInstAttrib; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoInstAttrib &noInstAttribCount(const std::uint8_t count) + { + m_noInstAttrib.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noInstAttrib; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noInstAttribSinceVersion() 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 NoLotTypeRules &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 * - LotTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t lotTypeId() SBE_NOEXCEPT { - return 1093; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lotTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lotTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noInstAttribInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lotTypeSinceVersion(); + return m_actingVersion >= noInstAttribSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lotTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int8_t lotTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t lotTypeMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t lotTypeMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t lotTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::int8_t lotType() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int8_t)); - return (val); - } - - NoLotTypeRules &lotType(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int8_t)); - return *this; - } - - SBE_NODISCARD static const char * - MinLotSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t minLotSizeId() SBE_NOEXCEPT { - return 1231; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minLotSizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool minLotSizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= minLotSizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minLotSizeEncodingOffset() SBE_NOEXCEPT { - return 1; - } + } + class NoLotTypeRules + { private: - DecimalQty m_minLotSize; + 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 DecimalQty &minLotSize() { - m_minLotSize.wrap( - m_buffer, m_offset + 1, m_actingVersion, m_bufferLength); - return m_minLotSize; - } + 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; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoLotTypeRules writer) { - builder << '{'; - builder << R"("LotType": )"; - builder << +writer.lotType(); + 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(5)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 5; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - builder << ", "; - builder << R"("MinLotSize": )"; - builder << writer.minLotSize(); + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } - builder << '}'; + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 5; + } - return builder; - } - }; + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - private: - NoLotTypeRules m_noLotTypeRules; + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoLotTypeRulesId() SBE_NOEXCEPT { - return 1234; - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - SBE_NODISCARD inline NoLotTypeRules &noLotTypeRules() { - m_noLotTypeRules.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLotTypeRules; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - NoLotTypeRules &noLotTypeRulesCount(const std::uint8_t count) { - m_noLotTypeRules.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLotTypeRules; - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noLotTypeRulesSinceVersion() SBE_NOEXCEPT { - return 0; - } + inline NoLotTypeRules &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 bool noLotTypeRulesInActingVersion() const SBE_NOEXCEPT { + 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(static_cast(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 *LotTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lotTypeId() SBE_NOEXCEPT + { + return 1093; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lotTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lotTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= lotTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lotTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::int8_t lotTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t lotTypeMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t lotTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t lotTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::int8_t lotType() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int8_t)); + return (val); + } + + NoLotTypeRules &lotType(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int8_t)); + return *this; + } + + SBE_NODISCARD static const char *MinLotSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t minLotSizeId() SBE_NOEXCEPT + { + return 1231; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minLotSizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool minLotSizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= minLotSizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minLotSizeEncodingOffset() SBE_NOEXCEPT + { + return 1; + } + +private: + DecimalQty m_minLotSize; + +public: + SBE_NODISCARD DecimalQty &minLotSize() + { + m_minLotSize.wrap(m_buffer, m_offset + 1, m_actingVersion, m_bufferLength); + return m_minLotSize; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoLotTypeRules writer) + { + builder << '{'; + builder << R"("LotType": )"; + builder << +writer.lotType(); + + builder << ", "; + builder << R"("MinLotSize": )"; + builder << writer.minLotSize(); + + 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: + NoLotTypeRules m_noLotTypeRules; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoLotTypeRulesId() SBE_NOEXCEPT + { + return 1234; + } + + SBE_NODISCARD inline NoLotTypeRules &noLotTypeRules() + { + m_noLotTypeRules.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLotTypeRules; + } + + NoLotTypeRules &noLotTypeRulesCount(const std::uint8_t count) + { + m_noLotTypeRules.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLotTypeRules; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noLotTypeRulesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noLotTypeRulesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noLotTypeRulesSinceVersion(); + return m_actingVersion >= noLotTypeRulesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDInstrumentDefinitionFuture54 _writer) { - MDInstrumentDefinitionFuture54 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDInstrumentDefinitionFuture54", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDInstrumentDefinitionFuture54 _writer) +{ + MDInstrumentDefinitionFuture54 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDInstrumentDefinitionFuture54", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); - builder << ", "; - builder << R"("TotNumReports": )"; - builder << +writer.totNumReports(); + builder << ", "; + builder << R"("TotNumReports": )"; + builder << +writer.totNumReports(); - builder << ", "; - builder << R"("SecurityUpdateAction": )"; - builder << '"' << writer.securityUpdateAction() << '"'; + builder << ", "; + builder << R"("SecurityUpdateAction": )"; + builder << '"' << writer.securityUpdateAction() << '"'; - builder << ", "; - builder << R"("LastUpdateTime": )"; - builder << +writer.lastUpdateTime(); + builder << ", "; + builder << R"("LastUpdateTime": )"; + builder << +writer.lastUpdateTime(); - builder << ", "; - builder << R"("MDSecurityTradingStatus": )"; - builder << '"' << writer.mDSecurityTradingStatus() << '"'; + builder << ", "; + builder << R"("MDSecurityTradingStatus": )"; + builder << '"' << writer.mDSecurityTradingStatus() << '"'; - builder << ", "; - builder << R"("ApplID": )"; - builder << +writer.applID(); + builder << ", "; + builder << R"("ApplID": )"; + builder << +writer.applID(); - builder << ", "; - builder << R"("MarketSegmentID": )"; - builder << +writer.marketSegmentID(); + builder << ", "; + builder << R"("MarketSegmentID": )"; + builder << +writer.marketSegmentID(); - builder << ", "; - builder << R"("UnderlyingProduct": )"; - builder << +writer.underlyingProduct(); + builder << ", "; + builder << R"("UnderlyingProduct": )"; + builder << +writer.underlyingProduct(); - builder << ", "; - builder << R"("SecurityExchange": )"; - builder << '"' << writer.getSecurityExchangeAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("SecurityExchange": )"; + builder << '"' << + writer.getSecurityExchangeAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("SecurityGroup": )"; - builder << '"' << writer.getSecurityGroupAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("SecurityGroup": )"; + builder << '"' << + writer.getSecurityGroupAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("Asset": )"; - builder << '"' << writer.getAssetAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("Asset": )"; + builder << '"' << + writer.getAssetAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("Symbol": )"; - builder << '"' << writer.getSymbolAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("Symbol": )"; + builder << '"' << + writer.getSymbolAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); - builder << ", "; - builder << R"("SecurityType": )"; - builder << '"' << writer.getSecurityTypeAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("SecurityType": )"; + builder << '"' << + writer.getSecurityTypeAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("CFICode": )"; - builder << '"' << writer.getCFICodeAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("CFICode": )"; + builder << '"' << + writer.getCFICodeAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("MaturityMonthYear": )"; - builder << writer.maturityMonthYear(); + builder << ", "; + builder << R"("MaturityMonthYear": )"; + builder << writer.maturityMonthYear(); - builder << ", "; - builder << R"("Currency": )"; - builder << '"' << writer.getCurrencyAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("Currency": )"; + builder << '"' << + writer.getCurrencyAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("SettlCurrency": )"; - builder << '"' << writer.getSettlCurrencyAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("SettlCurrency": )"; + builder << '"' << + writer.getSettlCurrencyAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("MatchAlgorithm": )"; - if (std::isprint(writer.matchAlgorithm())) { - builder << '"' << (char)writer.matchAlgorithm() << '"'; - } else { - builder << (int)writer.matchAlgorithm(); - } + builder << ", "; + builder << R"("MatchAlgorithm": )"; + if (std::isprint(writer.matchAlgorithm())) + { + builder << '"' << (char)writer.matchAlgorithm() << '"'; + } + else + { + builder << (int)writer.matchAlgorithm(); + } - builder << ", "; - builder << R"("MinTradeVol": )"; - builder << +writer.minTradeVol(); + builder << ", "; + builder << R"("MinTradeVol": )"; + builder << +writer.minTradeVol(); - builder << ", "; - builder << R"("MaxTradeVol": )"; - builder << +writer.maxTradeVol(); + builder << ", "; + builder << R"("MaxTradeVol": )"; + builder << +writer.maxTradeVol(); - builder << ", "; - builder << R"("MinPriceIncrement": )"; - builder << writer.minPriceIncrement(); + builder << ", "; + builder << R"("MinPriceIncrement": )"; + builder << writer.minPriceIncrement(); - builder << ", "; - builder << R"("DisplayFactor": )"; - builder << writer.displayFactor(); + builder << ", "; + builder << R"("DisplayFactor": )"; + builder << writer.displayFactor(); - builder << ", "; - builder << R"("MainFraction": )"; - builder << +writer.mainFraction(); + builder << ", "; + builder << R"("MainFraction": )"; + builder << +writer.mainFraction(); - builder << ", "; - builder << R"("SubFraction": )"; - builder << +writer.subFraction(); + builder << ", "; + builder << R"("SubFraction": )"; + builder << +writer.subFraction(); - builder << ", "; - builder << R"("PriceDisplayFormat": )"; - builder << +writer.priceDisplayFormat(); + builder << ", "; + builder << R"("PriceDisplayFormat": )"; + builder << +writer.priceDisplayFormat(); - builder << ", "; - builder << R"("UnitOfMeasure": )"; - builder << '"' << writer.getUnitOfMeasureAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("UnitOfMeasure": )"; + builder << '"' << + writer.getUnitOfMeasureAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("UnitOfMeasureQty": )"; - builder << writer.unitOfMeasureQty(); + builder << ", "; + builder << R"("UnitOfMeasureQty": )"; + builder << writer.unitOfMeasureQty(); - builder << ", "; - builder << R"("TradingReferencePrice": )"; - builder << writer.tradingReferencePrice(); + builder << ", "; + builder << R"("TradingReferencePrice": )"; + builder << writer.tradingReferencePrice(); - builder << ", "; - builder << R"("SettlPriceType": )"; - builder << writer.settlPriceType(); + builder << ", "; + builder << R"("SettlPriceType": )"; + builder << writer.settlPriceType(); - builder << ", "; - builder << R"("OpenInterestQty": )"; - builder << +writer.openInterestQty(); + builder << ", "; + builder << R"("OpenInterestQty": )"; + builder << +writer.openInterestQty(); - builder << ", "; - builder << R"("ClearedVolume": )"; - builder << +writer.clearedVolume(); + builder << ", "; + builder << R"("ClearedVolume": )"; + builder << +writer.clearedVolume(); - builder << ", "; - builder << R"("HighLimitPrice": )"; - builder << writer.highLimitPrice(); + builder << ", "; + builder << R"("HighLimitPrice": )"; + builder << writer.highLimitPrice(); - builder << ", "; - builder << R"("LowLimitPrice": )"; - builder << writer.lowLimitPrice(); + builder << ", "; + builder << R"("LowLimitPrice": )"; + builder << writer.lowLimitPrice(); - builder << ", "; - builder << R"("MaxPriceVariation": )"; - builder << writer.maxPriceVariation(); + builder << ", "; + builder << R"("MaxPriceVariation": )"; + builder << writer.maxPriceVariation(); - builder << ", "; - builder << R"("DecayQuantity": )"; - builder << +writer.decayQuantity(); + builder << ", "; + builder << R"("DecayQuantity": )"; + builder << +writer.decayQuantity(); - builder << ", "; - builder << R"("DecayStartDate": )"; - builder << +writer.decayStartDate(); + builder << ", "; + builder << R"("DecayStartDate": )"; + builder << +writer.decayStartDate(); - builder << ", "; - builder << R"("OriginalContractSize": )"; - builder << +writer.originalContractSize(); + builder << ", "; + builder << R"("OriginalContractSize": )"; + builder << +writer.originalContractSize(); - builder << ", "; - builder << R"("ContractMultiplier": )"; - builder << +writer.contractMultiplier(); + builder << ", "; + builder << R"("ContractMultiplier": )"; + builder << +writer.contractMultiplier(); - builder << ", "; - builder << R"("ContractMultiplierUnit": )"; - builder << +writer.contractMultiplierUnit(); + builder << ", "; + builder << R"("ContractMultiplierUnit": )"; + builder << +writer.contractMultiplierUnit(); - builder << ", "; - builder << R"("FlowScheduleType": )"; - builder << +writer.flowScheduleType(); + builder << ", "; + builder << R"("FlowScheduleType": )"; + builder << +writer.flowScheduleType(); - builder << ", "; - builder << R"("MinPriceIncrementAmount": )"; - builder << writer.minPriceIncrementAmount(); + builder << ", "; + builder << R"("MinPriceIncrementAmount": )"; + builder << writer.minPriceIncrementAmount(); - builder << ", "; - builder << R"("UserDefinedInstrument": )"; - if (std::isprint(writer.userDefinedInstrument())) { - builder << '"' << (char)writer.userDefinedInstrument() << '"'; - } else { - builder << (int)writer.userDefinedInstrument(); - } + builder << ", "; + builder << R"("UserDefinedInstrument": )"; + if (std::isprint(writer.userDefinedInstrument())) + { + builder << '"' << (char)writer.userDefinedInstrument() << '"'; + } + else + { + builder << (int)writer.userDefinedInstrument(); + } - builder << ", "; - builder << R"("TradingReferenceDate": )"; - builder << +writer.tradingReferenceDate(); + builder << ", "; + builder << R"("TradingReferenceDate": )"; + builder << +writer.tradingReferenceDate(); - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoEvents": [)"; - writer.noEvents().forEach([&](NoEvents &noEvents) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoEvents": [)"; + writer.noEvents().forEach([&](NoEvents& noEvents) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noEvents; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDFeedTypes": [)"; - writer.noMDFeedTypes().forEach([&](NoMDFeedTypes &noMDFeedTypes) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDFeedTypes": [)"; + writer.noMDFeedTypes().forEach([&](NoMDFeedTypes& noMDFeedTypes) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDFeedTypes; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoInstAttrib": [)"; - writer.noInstAttrib().forEach([&](NoInstAttrib &noInstAttrib) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoInstAttrib": [)"; + writer.noInstAttrib().forEach([&](NoInstAttrib& noInstAttrib) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noInstAttrib; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoLotTypeRules": [)"; - writer.noLotTypeRules().forEach([&](NoLotTypeRules &noLotTypeRules) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoLotTypeRules": [)"; + writer.noLotTypeRules().forEach([&](NoLotTypeRules& noLotTypeRules) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noLotTypeRules; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noEvents().forEach([](NoEvents e) + { + e.skip(); + }); + noMDFeedTypes().forEach([](NoMDFeedTypes e) + { + e.skip(); + }); + noInstAttrib().forEach([](NoInstAttrib e) + { + e.skip(); + }); + noLotTypeRules().forEach([](NoLotTypeRules e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noEventsLength = 0, + std::size_t noMDFeedTypesLength = 0, + std::size_t noInstAttribLength = 0, + std::size_t noLotTypeRulesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoEvents::sbeHeaderSize(); + if (noEventsLength > 254LL) + { + throw std::runtime_error("noEventsLength outside of allowed range [E110]"); + } + length += noEventsLength *NoEvents::sbeBlockLength(); + + length += NoMDFeedTypes::sbeHeaderSize(); + if (noMDFeedTypesLength > 254LL) + { + throw std::runtime_error("noMDFeedTypesLength outside of allowed range [E110]"); + } + length += noMDFeedTypesLength *NoMDFeedTypes::sbeBlockLength(); + + length += NoInstAttrib::sbeHeaderSize(); + if (noInstAttribLength > 254LL) + { + throw std::runtime_error("noInstAttribLength outside of allowed range [E110]"); + } + length += noInstAttribLength *NoInstAttrib::sbeBlockLength(); + + length += NoLotTypeRules::sbeHeaderSize(); + if (noLotTypeRulesLength > 254LL) + { + throw std::runtime_error("noLotTypeRulesLength outside of allowed range [E110]"); + } + length += noLotTypeRulesLength *NoLotTypeRules::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionOption41.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionOption41.h index 89780e5c4..c61f44687 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionOption41.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionOption41.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,7089 +86,7698 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDInstrumentDefinitionOption41 { - 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 MDInstrumentDefinitionOption41 +{ +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; } + 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(213); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(41); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDInstrumentDefinitionOption41() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDInstrumentDefinitionOption41( - 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; - MDInstrumentDefinitionOption41( - char *buffer, const std::uint64_t bufferLength) - : MDInstrumentDefinitionOption41( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDInstrumentDefinitionOption41() = default; - MDInstrumentDefinitionOption41( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDInstrumentDefinitionOption41( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDInstrumentDefinitionOption41( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)213; - } + MDInstrumentDefinitionOption41(char *buffer, const std::uint64_t bufferLength) : + MDInstrumentDefinitionOption41(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)41; - } + MDInstrumentDefinitionOption41( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDInstrumentDefinitionOption41(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(213); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "d"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(41); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDInstrumentDefinitionOption41 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDInstrumentDefinitionOption41( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDInstrumentDefinitionOption41 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "d"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDInstrumentDefinitionOption41( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDInstrumentDefinitionOption41 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDInstrumentDefinitionOption41(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDInstrumentDefinitionOption41 &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 = MDInstrumentDefinitionOption41( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDInstrumentDefinitionOption41 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDInstrumentDefinitionOption41( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDInstrumentDefinitionOption41 &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 = MDInstrumentDefinitionOption41(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MDInstrumentDefinitionOption41 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char *MatchEventIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MultipleCharValue"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char * - TotNumReportsMetaAttribute(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 *TotNumReportsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT { - return 911; - } + static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT + { + return 911; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totNumReportsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t totNumReportsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= totNumReportsSinceVersion(); + return m_actingVersion >= totNumReportsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totNumReportsEncodingOffset() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t totNumReportsEncodingOffset() SBE_NOEXCEPT + { + return 1; + } - static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t totNumReports() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t totNumReports() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionOption41 & - totNumReports(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint32_t)); - return *this; - } + MDInstrumentDefinitionOption41 &totNumReports(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char *SecurityUpdateActionMetaAttribute( - 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 *SecurityUpdateActionMetaAttribute(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 securityUpdateActionId() SBE_NOEXCEPT { - return 980; - } + static SBE_CONSTEXPR std::uint16_t securityUpdateActionId() SBE_NOEXCEPT + { + return 980; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityUpdateActionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityUpdateActionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityUpdateActionSinceVersion(); + return m_actingVersion >= securityUpdateActionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SecurityUpdateAction::Value - securityUpdateAction() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 5, sizeof(char)); - return SecurityUpdateAction::get((val)); - } + SBE_NODISCARD SecurityUpdateAction::Value securityUpdateAction() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 5, sizeof(char)); + return SecurityUpdateAction::get((val)); + } - MDInstrumentDefinitionOption41 & - securityUpdateAction(const SecurityUpdateAction::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 5, &val, sizeof(char)); - return *this; - } + MDInstrumentDefinitionOption41 &securityUpdateAction(const SecurityUpdateAction::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 5, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char * - LastUpdateTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LastUpdateTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t lastUpdateTimeId() SBE_NOEXCEPT { - return 779; - } + static SBE_CONSTEXPR std::uint16_t lastUpdateTimeId() SBE_NOEXCEPT + { + return 779; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastUpdateTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastUpdateTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lastUpdateTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lastUpdateTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastUpdateTimeSinceVersion(); + return m_actingVersion >= lastUpdateTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastUpdateTimeEncodingOffset() SBE_NOEXCEPT { - return 6; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastUpdateTimeEncodingOffset() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - lastUpdateTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t lastUpdateTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t lastUpdateTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 6, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t lastUpdateTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 6, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MDInstrumentDefinitionOption41 & - lastUpdateTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 6, &val, sizeof(std::uint64_t)); - return *this; - } + MDInstrumentDefinitionOption41 &lastUpdateTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 6, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *MDSecurityTradingStatusMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MDSecurityTradingStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mDSecurityTradingStatusId() SBE_NOEXCEPT { - return 1682; - } + static SBE_CONSTEXPR std::uint16_t mDSecurityTradingStatusId() SBE_NOEXCEPT + { + return 1682; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDSecurityTradingStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDSecurityTradingStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mDSecurityTradingStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mDSecurityTradingStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDSecurityTradingStatusSinceVersion(); + return m_actingVersion >= mDSecurityTradingStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDSecurityTradingStatusEncodingOffset() SBE_NOEXCEPT { - return 14; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDSecurityTradingStatusEncodingOffset() SBE_NOEXCEPT + { + return 14; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDSecurityTradingStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDSecurityTradingStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SecurityTradingStatus::Value - mDSecurityTradingStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); - return SecurityTradingStatus::get((val)); - } + SBE_NODISCARD SecurityTradingStatus::Value mDSecurityTradingStatus() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); + return SecurityTradingStatus::get((val)); + } - MDInstrumentDefinitionOption41 &mDSecurityTradingStatus( - const SecurityTradingStatus::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionOption41 &mDSecurityTradingStatus(const SecurityTradingStatus::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - ApplIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ApplIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t applIDId() SBE_NOEXCEPT { return 1180; } + static SBE_CONSTEXPR std::uint16_t applIDId() SBE_NOEXCEPT + { + return 1180; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - applIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t applIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool applIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool applIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= applIDSinceVersion(); + return m_actingVersion >= applIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - applIDEncodingOffset() SBE_NOEXCEPT { - return 15; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t applIDEncodingOffset() SBE_NOEXCEPT + { + return 15; + } - static SBE_CONSTEXPR std::int16_t applIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT16; - } + static SBE_CONSTEXPR std::int16_t applIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT16; + } - static SBE_CONSTEXPR std::int16_t applIDMinValue() SBE_NOEXCEPT { - return (std::int16_t)-32767; - } + static SBE_CONSTEXPR std::int16_t applIDMinValue() SBE_NOEXCEPT + { + return static_cast(-32767); + } - static SBE_CONSTEXPR std::int16_t applIDMaxValue() SBE_NOEXCEPT { - return (std::int16_t)32767; - } + static SBE_CONSTEXPR std::int16_t applIDMaxValue() SBE_NOEXCEPT + { + return static_cast(32767); + } - static SBE_CONSTEXPR std::size_t applIDEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t applIDEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::int16_t applID() const SBE_NOEXCEPT { - std::int16_t val; - std::memcpy(&val, m_buffer + m_offset + 15, sizeof(std::int16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::int16_t applID() const SBE_NOEXCEPT + { + std::int16_t val; + std::memcpy(&val, m_buffer + m_offset + 15, sizeof(std::int16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - MDInstrumentDefinitionOption41 & - applID(const std::int16_t value) SBE_NOEXCEPT { - std::int16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 15, &val, sizeof(std::int16_t)); - return *this; - } + MDInstrumentDefinitionOption41 &applID(const std::int16_t value) SBE_NOEXCEPT + { + std::int16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 15, &val, sizeof(std::int16_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 "required"; - 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 "required"; + 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 17; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t marketSegmentIDEncodingOffset() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } - 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 + 17, 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 + 17, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionOption41 & - marketSegmentID(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionOption41 &marketSegmentID(const std::uint8_t 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 *UnderlyingProductMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UnderlyingProductMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t underlyingProductId() SBE_NOEXCEPT { - return 462; - } + static SBE_CONSTEXPR std::uint16_t underlyingProductId() SBE_NOEXCEPT + { + return 462; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - underlyingProductSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t underlyingProductSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool underlyingProductInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool underlyingProductInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= underlyingProductSinceVersion(); + return m_actingVersion >= underlyingProductSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - underlyingProductEncodingOffset() SBE_NOEXCEPT { - return 18; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t underlyingProductEncodingOffset() SBE_NOEXCEPT + { + return 18; + } - static SBE_CONSTEXPR std::uint8_t underlyingProductNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR std::uint8_t underlyingProductNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } - static SBE_CONSTEXPR std::uint8_t underlyingProductMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t underlyingProductMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t underlyingProductMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t underlyingProductMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - underlyingProductEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t underlyingProductEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t underlyingProduct() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t underlyingProduct() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionOption41 & - underlyingProduct(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; - } + MDInstrumentDefinitionOption41 &underlyingProduct(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 static const char *SecurityExchangeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Exchange"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityExchangeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Exchange"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityExchangeId() SBE_NOEXCEPT { - return 207; - } + static SBE_CONSTEXPR std::uint16_t securityExchangeId() SBE_NOEXCEPT + { + return 207; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityExchangeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityExchangeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityExchangeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityExchangeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityExchangeSinceVersion(); + return m_actingVersion >= securityExchangeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityExchangeEncodingOffset() SBE_NOEXCEPT { - return 19; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityExchangeEncodingOffset() SBE_NOEXCEPT + { + return 19; + } - static SBE_CONSTEXPR char securityExchangeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityExchangeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityExchangeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityExchangeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityExchangeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char securityExchangeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - securityExchangeEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityExchangeEncodingLength() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t securityExchangeLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::uint64_t securityExchangeLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD const char *securityExchange() const SBE_NOEXCEPT { - return m_buffer + m_offset + 19; - } + SBE_NODISCARD const char *securityExchange() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 19; + } - SBE_NODISCARD char *securityExchange() SBE_NOEXCEPT { - return m_buffer + m_offset + 19; - } + SBE_NODISCARD char *securityExchange() SBE_NOEXCEPT + { + return m_buffer + m_offset + 19; + } - SBE_NODISCARD char securityExchange(const std::uint64_t index) const { - if (index >= 4) { - throw std::runtime_error( - "index out of range for securityExchange [E104]"); - } + SBE_NODISCARD char securityExchange(const std::uint64_t index) const + { + if (index >= 4) + { + throw std::runtime_error("index out of range for securityExchange [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 19 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 19 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption41 & - securityExchange(const std::uint64_t index, const char value) { - if (index >= 4) { - throw std::runtime_error( - "index out of range for securityExchange [E105]"); - } + MDInstrumentDefinitionOption41 &securityExchange(const std::uint64_t index, const char value) + { + if (index >= 4) + { + throw std::runtime_error("index out of range for securityExchange [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 19 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 19 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSecurityExchange(char *const dst, const std::uint64_t length) const { - if (length > 4) { - throw std::runtime_error( - "length too large for getSecurityExchange [E106]"); - } + std::uint64_t getSecurityExchange(char *const dst, const std::uint64_t length) const + { + if (length > 4) + { + throw std::runtime_error("length too large for getSecurityExchange [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 19, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 19, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionOption41 & - putSecurityExchange(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 19, src, sizeof(char) * 4); - return *this; - } + MDInstrumentDefinitionOption41 &putSecurityExchange(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 19, src, sizeof(char) * 4); + return *this; + } - MDInstrumentDefinitionOption41 &putSecurityExchange( - const char value0, - const char value1, - const char value2, - const char value3) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 19, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 20, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 21, &val2, sizeof(char)); - char val3 = (value3); - std::memcpy(m_buffer + m_offset + 22, &val3, sizeof(char)); + MDInstrumentDefinitionOption41 &putSecurityExchange( + const char value0, + const char value1, + const char value2, + const char value3) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 19, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 20, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 21, &val2, sizeof(char)); + char val3 = (value3); + std::memcpy(m_buffer + m_offset + 22, &val3, sizeof(char)); - return *this; - } + return *this; + } - std::string getSecurityExchangeAsString() const { - const char *buffer = m_buffer + m_offset + 19; - size_t length = 0; + SBE_NODISCARD std::string getSecurityExchangeAsString() const + { + const char *buffer = m_buffer + m_offset + 19; + size_t length = 0; - for (; length < 4 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 4 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSecurityExchangeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityExchangeAsString(); + std::string getSecurityExchangeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityExchangeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityExchangeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 19; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityExchangeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 19; + size_t length = 0; - for (; length < 4 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 4 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - MDInstrumentDefinitionOption41 & - putSecurityExchange(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 4) { - throw std::runtime_error( - "string too large for putSecurityExchange [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionOption41 &putSecurityExchange(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 4) + { + throw std::runtime_error("string too large for putSecurityExchange [E106]"); + } - std::memcpy(m_buffer + m_offset + 19, str.data(), srcLength); - for (size_t start = srcLength; start < 4; ++start) { - m_buffer[m_offset + 19 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 19, str.data(), srcLength); + for (size_t start = srcLength; start < 4; ++start) + { + m_buffer[m_offset + 19 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption41 &putSecurityExchange(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 4) { - throw std::runtime_error( - "string too large for putSecurityExchange [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionOption41 &putSecurityExchange(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 4) + { + throw std::runtime_error("string too large for putSecurityExchange [E106]"); + } - std::memcpy(m_buffer + m_offset + 19, str.c_str(), srcLength); - for (size_t start = srcLength; start < 4; ++start) { - m_buffer[m_offset + 19 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 19, str.c_str(), srcLength); + for (size_t start = srcLength; start < 4; ++start) + { + m_buffer[m_offset + 19 + start] = 0; + } - return *this; - } -#endif + return *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 "required"; - 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 "required"; + 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 23; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityGroupEncodingOffset() SBE_NOEXCEPT + { + return 23; + } - 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 + 23; - } + SBE_NODISCARD const char *securityGroup() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 23; + } - SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT { - return m_buffer + m_offset + 23; - } + SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT + { + return m_buffer + m_offset + 23; + } - 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 + 23 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 23 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption41 & - securityGroup(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E105]"); - } + MDInstrumentDefinitionOption41 &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 + 23 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 23 + (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 + 23, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 23, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionOption41 & - putSecurityGroup(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 23, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionOption41 &putSecurityGroup(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 23, src, sizeof(char) * 6); + return *this; + } - std::string getSecurityGroupAsString() const { - const char *buffer = m_buffer + m_offset + 23; - size_t length = 0; + SBE_NODISCARD std::string getSecurityGroupAsString() const + { + const char *buffer = m_buffer + m_offset + 23; + 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 (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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityGroupAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 23; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 23; + 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 - MDInstrumentDefinitionOption41 & - 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 + MDInstrumentDefinitionOption41 &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 + 23, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 23 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 23, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 23 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption41 &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 + MDInstrumentDefinitionOption41 &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 + 23, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 23 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 23, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 23 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - AssetMetaAttribute(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 *AssetMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t assetId() SBE_NOEXCEPT { return 6937; } + static SBE_CONSTEXPR std::uint16_t assetId() SBE_NOEXCEPT + { + return 6937; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - assetSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t assetSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool assetInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool assetInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= assetSinceVersion(); + return m_actingVersion >= assetSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - assetEncodingOffset() SBE_NOEXCEPT { - return 29; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t assetEncodingOffset() SBE_NOEXCEPT + { + return 29; + } - static SBE_CONSTEXPR char assetNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char assetNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char assetMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char assetMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char assetMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char assetMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t assetEncodingLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::size_t assetEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t assetLength() SBE_NOEXCEPT { return 6; } + static SBE_CONSTEXPR std::uint64_t assetLength() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD const char *asset() const SBE_NOEXCEPT { - return m_buffer + m_offset + 29; - } + SBE_NODISCARD const char *asset() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 29; + } - SBE_NODISCARD char *asset() SBE_NOEXCEPT { return m_buffer + m_offset + 29; } + SBE_NODISCARD char *asset() SBE_NOEXCEPT + { + return m_buffer + m_offset + 29; + } - SBE_NODISCARD char asset(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for asset [E104]"); - } + SBE_NODISCARD char asset(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for asset [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 29 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 29 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption41 & - asset(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for asset [E105]"); - } + MDInstrumentDefinitionOption41 &asset(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for asset [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 29 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 29 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getAsset(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error("length too large for getAsset [E106]"); - } + std::uint64_t getAsset(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getAsset [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 29, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 29, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionOption41 & - putAsset(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 29, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionOption41 &putAsset(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 29, src, sizeof(char) * 6); + return *this; + } - std::string getAssetAsString() const { - const char *buffer = m_buffer + m_offset + 29; - size_t length = 0; + SBE_NODISCARD std::string getAssetAsString() const + { + const char *buffer = m_buffer + m_offset + 29; + 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 getAssetAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getAssetAsString(); + std::string getAssetAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getAssetAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getAssetAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 29; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getAssetAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 29; + 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 - MDInstrumentDefinitionOption41 &putAsset(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putAsset [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionOption41 &putAsset(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putAsset [E106]"); + } - std::memcpy(m_buffer + m_offset + 29, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 29 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 29, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 29 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption41 &putAsset(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putAsset [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionOption41 &putAsset(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putAsset [E106]"); + } - std::memcpy(m_buffer + m_offset + 29, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 29 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 29, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 29 + start] = 0; + } - return *this; - } -#endif + 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 "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SymbolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t symbolId() SBE_NOEXCEPT { return 55; } + 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 static SBE_CONSTEXPR std::uint64_t symbolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool symbolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool symbolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= symbolSinceVersion(); + return m_actingVersion >= symbolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - symbolEncodingOffset() SBE_NOEXCEPT { - return 35; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t symbolEncodingOffset() SBE_NOEXCEPT + { + return 35; + } - static SBE_CONSTEXPR char symbolNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char symbolNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char symbolMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char symbolMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char symbolMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char symbolMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t symbolEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t symbolEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t symbolLength() 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 + 35; - } + SBE_NODISCARD const char *symbol() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 35; + } - SBE_NODISCARD char *symbol() SBE_NOEXCEPT { - return m_buffer + m_offset + 35; - } + SBE_NODISCARD char *symbol() SBE_NOEXCEPT + { + return m_buffer + m_offset + 35; + } - SBE_NODISCARD char symbol(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for symbol [E104]"); - } + 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 + 35 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 35 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption41 & - symbol(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for symbol [E105]"); - } + MDInstrumentDefinitionOption41 &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 + 35 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 35 + (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::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 + 35, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 35, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionOption41 & - putSymbol(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 35, src, sizeof(char) * 20); - return *this; - } + MDInstrumentDefinitionOption41 &putSymbol(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 35, src, sizeof(char) * 20); + return *this; + } - std::string getSymbolAsString() const { - const char *buffer = m_buffer + m_offset + 35; - size_t length = 0; + SBE_NODISCARD std::string getSymbolAsString() const + { + const char *buffer = m_buffer + m_offset + 35; + 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 getSymbolAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSymbolAsString(); + std::string getSymbolAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSymbolAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSymbolAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 35; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSymbolAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 35; + 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 - MDInstrumentDefinitionOption41 &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]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionOption41 &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 + 35, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 35 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 35, str.data(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 35 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption41 &putSymbol(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSymbol [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionOption41 &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 + 35, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 35 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 35, str.c_str(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 35 + 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 55; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 55; + } - 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 + 55, 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 + 55, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionOption41 & - securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 55, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionOption41 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 55, &val, sizeof(std::int32_t)); + return *this; + } - 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 ""; - } - } + 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; - } + 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 static SBE_CONSTEXPR std::uint64_t securityIDSourceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDSourceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDSourceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSourceSinceVersion(); + return m_actingVersion >= securityIDSourceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDSourceEncodingOffset() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDSourceEncodingOffset() SBE_NOEXCEPT + { + return 59; + } - static SBE_CONSTEXPR char securityIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityIDSourceNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityIDSourceMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityIDSourceMaxValue() SBE_NOEXCEPT { - return (char)126; - } + 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::size_t securityIDSourceEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t securityIDSourceLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t securityIDSourceLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *securityIDSource() const { - static const std::uint8_t securityIDSourceValues[] = {56}; + SBE_NODISCARD const char *securityIDSource() const + { + static const std::uint8_t securityIDSourceValues[] = { 56 }; - return (const char *)securityIDSourceValues; - } + return (const char *)securityIDSourceValues; + } - SBE_NODISCARD char securityIDSource(const std::uint64_t index) const { - static const std::uint8_t securityIDSourceValues[] = {56}; + SBE_NODISCARD char securityIDSource(const std::uint64_t index) const + { + static const std::uint8_t securityIDSourceValues[] = { 56 }; - return (char)securityIDSourceValues[index]; - } + 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::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::memcpy(dst, securityIDSourceValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getSecurityIDSourceAsString() const { - static const std::uint8_t SecurityIDSourceValues[] = {56}; + std::string getSecurityIDSourceAsString() const + { + static const std::uint8_t SecurityIDSourceValues[] = { 56 }; - return std::string((const char *)SecurityIDSourceValues, 1); - } + return std::string((const char *)SecurityIDSourceValues, 1); + } - std::string getSecurityIDSourceAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityIDSourceAsString(); + std::string getSecurityIDSourceAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityIDSourceAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 * - SecurityTypeMetaAttribute(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 *SecurityTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityTypeId() SBE_NOEXCEPT { - return 167; - } + 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 static SBE_CONSTEXPR std::uint64_t securityTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityTypeSinceVersion(); + return m_actingVersion >= securityTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityTypeEncodingOffset() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityTypeEncodingOffset() SBE_NOEXCEPT + { + return 59; + } - static SBE_CONSTEXPR char securityTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + 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::size_t securityTypeEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t securityTypeLength() 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 + 59; - } + SBE_NODISCARD const char *securityType() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 59; + } - SBE_NODISCARD char *securityType() SBE_NOEXCEPT { - return m_buffer + m_offset + 59; - } + SBE_NODISCARD char *securityType() SBE_NOEXCEPT + { + return m_buffer + m_offset + 59; + } - SBE_NODISCARD char securityType(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for securityType [E104]"); - } + 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 + 59 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 59 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption41 & - securityType(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for securityType [E105]"); - } + MDInstrumentDefinitionOption41 &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 + 59 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 59 + (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::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 + 59, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 59, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionOption41 & - putSecurityType(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 59, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionOption41 &putSecurityType(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 59, src, sizeof(char) * 6); + return *this; + } - std::string getSecurityTypeAsString() const { - const char *buffer = m_buffer + m_offset + 59; - size_t length = 0; + SBE_NODISCARD std::string getSecurityTypeAsString() const + { + const char *buffer = m_buffer + m_offset + 59; + 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 getSecurityTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityTypeAsString(); + std::string getSecurityTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityTypeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityTypeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 59; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityTypeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 59; + 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 - MDInstrumentDefinitionOption41 &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]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionOption41 &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 + 59, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 59 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 59, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 59 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption41 &putSecurityType(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityType [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionOption41 &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 + 59, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 59 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 59, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 59 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - CFICodeMetaAttribute(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 *CFICodeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t cFICodeId() SBE_NOEXCEPT { return 461; } + static SBE_CONSTEXPR std::uint16_t cFICodeId() SBE_NOEXCEPT + { + return 461; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cFICodeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cFICodeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool cFICodeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool cFICodeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= cFICodeSinceVersion(); + return m_actingVersion >= cFICodeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cFICodeEncodingOffset() SBE_NOEXCEPT { - return 65; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cFICodeEncodingOffset() SBE_NOEXCEPT + { + return 65; + } - static SBE_CONSTEXPR char cFICodeNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char cFICodeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char cFICodeMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char cFICodeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char cFICodeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char cFICodeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t cFICodeEncodingLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::size_t cFICodeEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t cFICodeLength() SBE_NOEXCEPT { return 6; } + static SBE_CONSTEXPR std::uint64_t cFICodeLength() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD const char *cFICode() const SBE_NOEXCEPT { - return m_buffer + m_offset + 65; - } + SBE_NODISCARD const char *cFICode() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 65; + } - SBE_NODISCARD char *cFICode() SBE_NOEXCEPT { - return m_buffer + m_offset + 65; - } + SBE_NODISCARD char *cFICode() SBE_NOEXCEPT + { + return m_buffer + m_offset + 65; + } - SBE_NODISCARD char cFICode(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for cFICode [E104]"); - } + SBE_NODISCARD char cFICode(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for cFICode [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); + } - MDInstrumentDefinitionOption41 & - cFICode(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for cFICode [E105]"); - } + MDInstrumentDefinitionOption41 &cFICode(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for cFICode [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 getCFICode(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error("length too large for getCFICode [E106]"); - } + std::uint64_t getCFICode(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getCFICode [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; + } - MDInstrumentDefinitionOption41 & - putCFICode(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 65, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionOption41 &putCFICode(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 65, src, sizeof(char) * 6); + return *this; + } - std::string getCFICodeAsString() const { - const char *buffer = m_buffer + m_offset + 65; - size_t length = 0; + SBE_NODISCARD std::string getCFICodeAsString() const + { + const char *buffer = m_buffer + m_offset + 65; + 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 getCFICodeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCFICodeAsString(); + std::string getCFICodeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCFICodeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getCFICodeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 65; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCFICodeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 65; + 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 - MDInstrumentDefinitionOption41 &putCFICode(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putCFICode [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionOption41 &putCFICode(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putCFICode [E106]"); + } - std::memcpy(m_buffer + m_offset + 65, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 65 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 65, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 65 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption41 &putCFICode(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putCFICode [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionOption41 &putCFICode(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putCFICode [E106]"); + } - std::memcpy(m_buffer + m_offset + 65, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 65 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 65, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 65 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - PutOrCallMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PutOrCallMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t putOrCallId() SBE_NOEXCEPT { return 201; } + static SBE_CONSTEXPR std::uint16_t putOrCallId() SBE_NOEXCEPT + { + return 201; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - putOrCallSinceVersion() SBE_NOEXCEPT { - return 3; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t putOrCallSinceVersion() SBE_NOEXCEPT + { + return 3; + } - SBE_NODISCARD bool putOrCallInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool putOrCallInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= putOrCallSinceVersion(); + return m_actingVersion >= putOrCallSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - putOrCallEncodingOffset() SBE_NOEXCEPT { - return 71; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t putOrCallEncodingOffset() SBE_NOEXCEPT + { + return 71; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - putOrCallEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t putOrCallEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD PutOrCall::Value putOrCall() const SBE_NOEXCEPT { - if (m_actingVersion < 3) { - return PutOrCall::NULL_VALUE; - } + SBE_NODISCARD PutOrCall::Value putOrCall() const + { + if (m_actingVersion < 3) + { + return PutOrCall::NULL_VALUE; + } - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 71, sizeof(std::uint8_t)); - return PutOrCall::get((val)); - } + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 71, sizeof(std::uint8_t)); + return PutOrCall::get((val)); + } - MDInstrumentDefinitionOption41 & - putOrCall(const PutOrCall::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 71, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionOption41 &putOrCall(const PutOrCall::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 static const char *MaturityMonthYearMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MonthYear"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + 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; - } + 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 static SBE_CONSTEXPR std::uint64_t maturityMonthYearSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool maturityMonthYearInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool maturityMonthYearInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= maturityMonthYearSinceVersion(); + return m_actingVersion >= maturityMonthYearSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maturityMonthYearEncodingOffset() SBE_NOEXCEPT { - return 72; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maturityMonthYearEncodingOffset() SBE_NOEXCEPT + { + return 72; + } - private: - MaturityMonthYear m_maturityMonthYear; +private: + MaturityMonthYear m_maturityMonthYear; - public: - SBE_NODISCARD MaturityMonthYear &maturityMonthYear() { - m_maturityMonthYear.wrap( - m_buffer, m_offset + 72, m_actingVersion, m_bufferLength); - return m_maturityMonthYear; - } +public: + SBE_NODISCARD MaturityMonthYear &maturityMonthYear() + { + m_maturityMonthYear.wrap(m_buffer, m_offset + 72, m_actingVersion, m_bufferLength); + return m_maturityMonthYear; + } - SBE_NODISCARD static const char * - CurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Currency"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Currency"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t currencyId() SBE_NOEXCEPT { return 15; } + 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 static SBE_CONSTEXPR std::uint64_t currencySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool currencyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool currencyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= currencySinceVersion(); + return m_actingVersion >= currencySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - currencyEncodingOffset() SBE_NOEXCEPT { - return 77; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t currencyEncodingOffset() SBE_NOEXCEPT + { + return 77; + } - static SBE_CONSTEXPR char currencyNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char currencyNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char currencyMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char currencyMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char currencyMaxValue() SBE_NOEXCEPT { - return (char)126; - } + 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::size_t currencyEncodingLength() SBE_NOEXCEPT + { + return 3; + } - static SBE_CONSTEXPR std::uint64_t currencyLength() 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 + 77; - } + SBE_NODISCARD const char *currency() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 77; + } - SBE_NODISCARD char *currency() SBE_NOEXCEPT { - return m_buffer + m_offset + 77; - } + SBE_NODISCARD char *currency() SBE_NOEXCEPT + { + return m_buffer + m_offset + 77; + } - SBE_NODISCARD char currency(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error("index out of range for currency [E104]"); - } + 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 + 77 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 77 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption41 & - currency(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error("index out of range for currency [E105]"); - } + MDInstrumentDefinitionOption41 ¤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 + 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 - getCurrency(char *const dst, const std::uint64_t length) const { - if (length > 3) { - throw std::runtime_error("length too large for getCurrency [E106]"); - } + 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 + 77, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 77, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionOption41 & - putCurrency(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 77, src, sizeof(char) * 3); - return *this; - } + MDInstrumentDefinitionOption41 &putCurrency(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 77, src, sizeof(char) * 3); + return *this; + } - MDInstrumentDefinitionOption41 &putCurrency( - const char value0, const char value1, const char value2) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 77, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 78, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 79, &val2, sizeof(char)); + MDInstrumentDefinitionOption41 &putCurrency( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 77, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 78, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 79, &val2, sizeof(char)); - return *this; - } + return *this; + } - std::string getCurrencyAsString() const { - const char *buffer = m_buffer + m_offset + 77; - size_t length = 0; + SBE_NODISCARD std::string getCurrencyAsString() const + { + const char *buffer = m_buffer + m_offset + 77; + 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 getCurrencyAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCurrencyAsString(); + std::string getCurrencyAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCurrencyAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getCurrencyAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 77; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCurrencyAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 77; + 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 - MDInstrumentDefinitionOption41 &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]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionOption41 &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 + 77, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 77 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 77, str.data(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 77 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption41 &putCurrency(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error("string too large for putCurrency [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionOption41 &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 + 77, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 77 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 77, str.c_str(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 77 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - StrikePriceMetaAttribute(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 *StrikePriceMetaAttribute(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 strikePriceId() SBE_NOEXCEPT { - return 202; - } + static SBE_CONSTEXPR std::uint16_t strikePriceId() SBE_NOEXCEPT + { + return 202; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - strikePriceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t strikePriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool strikePriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool strikePriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= strikePriceSinceVersion(); + return m_actingVersion >= strikePriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - strikePriceEncodingOffset() SBE_NOEXCEPT { - return 80; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t strikePriceEncodingOffset() SBE_NOEXCEPT + { + return 80; + } - private: - PRICENULL m_strikePrice; +private: + PRICENULL m_strikePrice; - public: - SBE_NODISCARD PRICENULL &strikePrice() { - m_strikePrice.wrap( - m_buffer, m_offset + 80, m_actingVersion, m_bufferLength); - return m_strikePrice; - } +public: + SBE_NODISCARD PRICENULL &strikePrice() + { + m_strikePrice.wrap(m_buffer, m_offset + 80, m_actingVersion, m_bufferLength); + return m_strikePrice; + } - SBE_NODISCARD static const char * - StrikeCurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Currency"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *StrikeCurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Currency"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t strikeCurrencyId() SBE_NOEXCEPT { - return 947; - } + static SBE_CONSTEXPR std::uint16_t strikeCurrencyId() SBE_NOEXCEPT + { + return 947; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - strikeCurrencySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t strikeCurrencySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool strikeCurrencyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool strikeCurrencyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= strikeCurrencySinceVersion(); + return m_actingVersion >= strikeCurrencySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - strikeCurrencyEncodingOffset() SBE_NOEXCEPT { - return 88; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t strikeCurrencyEncodingOffset() SBE_NOEXCEPT + { + return 88; + } - static SBE_CONSTEXPR char strikeCurrencyNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char strikeCurrencyNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char strikeCurrencyMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char strikeCurrencyMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char strikeCurrencyMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char strikeCurrencyMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - strikeCurrencyEncodingLength() SBE_NOEXCEPT { - return 3; - } + static SBE_CONSTEXPR std::size_t strikeCurrencyEncodingLength() SBE_NOEXCEPT + { + return 3; + } - static SBE_CONSTEXPR std::uint64_t strikeCurrencyLength() SBE_NOEXCEPT { - return 3; - } + static SBE_CONSTEXPR std::uint64_t strikeCurrencyLength() SBE_NOEXCEPT + { + return 3; + } - SBE_NODISCARD const char *strikeCurrency() const SBE_NOEXCEPT { - return m_buffer + m_offset + 88; - } + SBE_NODISCARD const char *strikeCurrency() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 88; + } - SBE_NODISCARD char *strikeCurrency() SBE_NOEXCEPT { - return m_buffer + m_offset + 88; - } + SBE_NODISCARD char *strikeCurrency() SBE_NOEXCEPT + { + return m_buffer + m_offset + 88; + } - SBE_NODISCARD char strikeCurrency(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error( - "index out of range for strikeCurrency [E104]"); - } + SBE_NODISCARD char strikeCurrency(const std::uint64_t index) const + { + if (index >= 3) + { + throw std::runtime_error("index out of range for strikeCurrency [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 88 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 88 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption41 & - strikeCurrency(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error( - "index out of range for strikeCurrency [E105]"); - } + MDInstrumentDefinitionOption41 &strikeCurrency(const std::uint64_t index, const char value) + { + if (index >= 3) + { + throw std::runtime_error("index out of range for strikeCurrency [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 88 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 88 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getStrikeCurrency(char *const dst, const std::uint64_t length) const { - if (length > 3) { - throw std::runtime_error( - "length too large for getStrikeCurrency [E106]"); - } + std::uint64_t getStrikeCurrency(char *const dst, const std::uint64_t length) const + { + if (length > 3) + { + throw std::runtime_error("length too large for getStrikeCurrency [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 88, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 88, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionOption41 & - putStrikeCurrency(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 88, src, sizeof(char) * 3); - return *this; - } + MDInstrumentDefinitionOption41 &putStrikeCurrency(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 88, src, sizeof(char) * 3); + return *this; + } - MDInstrumentDefinitionOption41 &putStrikeCurrency( - const char value0, const char value1, const char value2) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 88, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 89, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 90, &val2, sizeof(char)); + MDInstrumentDefinitionOption41 &putStrikeCurrency( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 88, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 89, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 90, &val2, sizeof(char)); - return *this; - } + return *this; + } - std::string getStrikeCurrencyAsString() const { - const char *buffer = m_buffer + m_offset + 88; - size_t length = 0; + SBE_NODISCARD std::string getStrikeCurrencyAsString() const + { + const char *buffer = m_buffer + m_offset + 88; + 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 getStrikeCurrencyAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getStrikeCurrencyAsString(); + std::string getStrikeCurrencyAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getStrikeCurrencyAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getStrikeCurrencyAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 88; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getStrikeCurrencyAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 88; + 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 - MDInstrumentDefinitionOption41 & - putStrikeCurrency(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putStrikeCurrency [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionOption41 &putStrikeCurrency(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putStrikeCurrency [E106]"); + } - std::memcpy(m_buffer + m_offset + 88, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 88 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 88, str.data(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 88 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption41 &putStrikeCurrency(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putStrikeCurrency [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionOption41 &putStrikeCurrency(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putStrikeCurrency [E106]"); + } - std::memcpy(m_buffer + m_offset + 88, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 88 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 88, str.c_str(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 88 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SettlCurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Currency"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SettlCurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Currency"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t settlCurrencyId() SBE_NOEXCEPT { - return 120; - } + static SBE_CONSTEXPR std::uint16_t settlCurrencyId() SBE_NOEXCEPT + { + return 120; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - settlCurrencySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t settlCurrencySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool settlCurrencyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool settlCurrencyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= settlCurrencySinceVersion(); + return m_actingVersion >= settlCurrencySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - settlCurrencyEncodingOffset() SBE_NOEXCEPT { - return 91; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t settlCurrencyEncodingOffset() SBE_NOEXCEPT + { + return 91; + } - static SBE_CONSTEXPR char settlCurrencyNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char settlCurrencyNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char settlCurrencyMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char settlCurrencyMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char settlCurrencyMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char settlCurrencyMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t settlCurrencyEncodingLength() SBE_NOEXCEPT { - return 3; - } + static SBE_CONSTEXPR std::size_t settlCurrencyEncodingLength() SBE_NOEXCEPT + { + return 3; + } - static SBE_CONSTEXPR std::uint64_t settlCurrencyLength() SBE_NOEXCEPT { - return 3; - } + static SBE_CONSTEXPR std::uint64_t settlCurrencyLength() SBE_NOEXCEPT + { + return 3; + } - SBE_NODISCARD const char *settlCurrency() const SBE_NOEXCEPT { - return m_buffer + m_offset + 91; - } + SBE_NODISCARD const char *settlCurrency() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 91; + } - SBE_NODISCARD char *settlCurrency() SBE_NOEXCEPT { - return m_buffer + m_offset + 91; - } + SBE_NODISCARD char *settlCurrency() SBE_NOEXCEPT + { + return m_buffer + m_offset + 91; + } - SBE_NODISCARD char settlCurrency(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error( - "index out of range for settlCurrency [E104]"); - } + SBE_NODISCARD char settlCurrency(const std::uint64_t index) const + { + if (index >= 3) + { + throw std::runtime_error("index out of range for settlCurrency [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 91 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 91 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption41 & - settlCurrency(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error( - "index out of range for settlCurrency [E105]"); - } + MDInstrumentDefinitionOption41 &settlCurrency(const std::uint64_t index, const char value) + { + if (index >= 3) + { + throw std::runtime_error("index out of range for settlCurrency [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 91 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 91 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSettlCurrency(char *const dst, const std::uint64_t length) const { - if (length > 3) { - throw std::runtime_error( - "length too large for getSettlCurrency [E106]"); - } + std::uint64_t getSettlCurrency(char *const dst, const std::uint64_t length) const + { + if (length > 3) + { + throw std::runtime_error("length too large for getSettlCurrency [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 91, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 91, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionOption41 & - putSettlCurrency(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 91, src, sizeof(char) * 3); - return *this; - } + MDInstrumentDefinitionOption41 &putSettlCurrency(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 91, src, sizeof(char) * 3); + return *this; + } - MDInstrumentDefinitionOption41 &putSettlCurrency( - const char value0, const char value1, const char value2) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 91, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 92, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 93, &val2, sizeof(char)); + MDInstrumentDefinitionOption41 &putSettlCurrency( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 91, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 92, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 93, &val2, sizeof(char)); - return *this; - } + return *this; + } - std::string getSettlCurrencyAsString() const { - const char *buffer = m_buffer + m_offset + 91; - size_t length = 0; + SBE_NODISCARD std::string getSettlCurrencyAsString() const + { + const char *buffer = m_buffer + m_offset + 91; + 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 getSettlCurrencyAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSettlCurrencyAsString(); + std::string getSettlCurrencyAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSettlCurrencyAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSettlCurrencyAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 91; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSettlCurrencyAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 91; + 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 - MDInstrumentDefinitionOption41 & - putSettlCurrency(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putSettlCurrency [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionOption41 &putSettlCurrency(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putSettlCurrency [E106]"); + } - std::memcpy(m_buffer + m_offset + 91, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 91 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 91, str.data(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 91 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption41 &putSettlCurrency(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putSettlCurrency [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionOption41 &putSettlCurrency(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putSettlCurrency [E106]"); + } - std::memcpy(m_buffer + m_offset + 91, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 91 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 91, str.c_str(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 91 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - MinCabPriceMetaAttribute(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 *MinCabPriceMetaAttribute(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 minCabPriceId() SBE_NOEXCEPT { - return 9850; - } + static SBE_CONSTEXPR std::uint16_t minCabPriceId() SBE_NOEXCEPT + { + return 9850; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minCabPriceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minCabPriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minCabPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minCabPriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minCabPriceSinceVersion(); + return m_actingVersion >= minCabPriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minCabPriceEncodingOffset() SBE_NOEXCEPT { - return 94; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minCabPriceEncodingOffset() SBE_NOEXCEPT + { + return 94; + } - private: - PRICENULL m_minCabPrice; +private: + PRICENULL m_minCabPrice; - public: - SBE_NODISCARD PRICENULL &minCabPrice() { - m_minCabPrice.wrap( - m_buffer, m_offset + 94, m_actingVersion, m_bufferLength); - return m_minCabPrice; - } +public: + SBE_NODISCARD PRICENULL &minCabPrice() + { + m_minCabPrice.wrap(m_buffer, m_offset + 94, m_actingVersion, m_bufferLength); + return m_minCabPrice; + } - SBE_NODISCARD static const char * - MatchAlgorithmMetaAttribute(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 *MatchAlgorithmMetaAttribute(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 matchAlgorithmId() SBE_NOEXCEPT { - return 1142; - } + static SBE_CONSTEXPR std::uint16_t matchAlgorithmId() SBE_NOEXCEPT + { + return 1142; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchAlgorithmSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchAlgorithmSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchAlgorithmInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchAlgorithmInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchAlgorithmSinceVersion(); + return m_actingVersion >= matchAlgorithmSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchAlgorithmEncodingOffset() SBE_NOEXCEPT { - return 102; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchAlgorithmEncodingOffset() SBE_NOEXCEPT + { + return 102; + } - static SBE_CONSTEXPR char matchAlgorithmNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char matchAlgorithmNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char matchAlgorithmMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char matchAlgorithmMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char matchAlgorithmMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char matchAlgorithmMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - matchAlgorithmEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchAlgorithmEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD char matchAlgorithm() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 102, sizeof(char)); - return (val); - } + SBE_NODISCARD char matchAlgorithm() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 102, sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption41 & - matchAlgorithm(const char value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 102, &val, sizeof(char)); - return *this; - } + MDInstrumentDefinitionOption41 &matchAlgorithm(const char value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 102, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char * - MinTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MinTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t minTradeVolId() SBE_NOEXCEPT { - return 562; - } + static SBE_CONSTEXPR std::uint16_t minTradeVolId() SBE_NOEXCEPT + { + return 562; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minTradeVolSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minTradeVolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minTradeVolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minTradeVolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minTradeVolSinceVersion(); + return m_actingVersion >= minTradeVolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minTradeVolEncodingOffset() SBE_NOEXCEPT { - return 103; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minTradeVolEncodingOffset() SBE_NOEXCEPT + { + return 103; + } - static SBE_CONSTEXPR std::uint32_t minTradeVolNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t minTradeVolNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t minTradeVolMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t minTradeVolMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t minTradeVolMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t minTradeVolMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t minTradeVolEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t minTradeVolEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t minTradeVol() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 103, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t minTradeVol() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 103, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionOption41 & - minTradeVol(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 103, &val, sizeof(std::uint32_t)); - return *this; - } + MDInstrumentDefinitionOption41 &minTradeVol(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 103, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - MaxTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MaxTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t maxTradeVolId() SBE_NOEXCEPT { - return 1140; - } + static SBE_CONSTEXPR std::uint16_t maxTradeVolId() SBE_NOEXCEPT + { + return 1140; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - maxTradeVolSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maxTradeVolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool maxTradeVolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool maxTradeVolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= maxTradeVolSinceVersion(); + return m_actingVersion >= maxTradeVolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maxTradeVolEncodingOffset() SBE_NOEXCEPT { - return 107; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maxTradeVolEncodingOffset() SBE_NOEXCEPT + { + return 107; + } - static SBE_CONSTEXPR std::uint32_t maxTradeVolNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t maxTradeVolNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t maxTradeVolMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t maxTradeVolMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t maxTradeVolMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t maxTradeVolMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t maxTradeVolEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t maxTradeVolEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t maxTradeVol() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 107, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t maxTradeVol() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 107, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionOption41 & - maxTradeVol(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 107, &val, sizeof(std::uint32_t)); - return *this; - } + MDInstrumentDefinitionOption41 &maxTradeVol(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 107, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char *MinPriceIncrementMetaAttribute( - 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 *MinPriceIncrementMetaAttribute(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 minPriceIncrementId() SBE_NOEXCEPT { - return 969; - } + static SBE_CONSTEXPR std::uint16_t minPriceIncrementId() SBE_NOEXCEPT + { + return 969; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minPriceIncrementSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minPriceIncrementSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minPriceIncrementInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minPriceIncrementInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minPriceIncrementSinceVersion(); + return m_actingVersion >= minPriceIncrementSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minPriceIncrementEncodingOffset() SBE_NOEXCEPT { - return 111; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minPriceIncrementEncodingOffset() SBE_NOEXCEPT + { + return 111; + } - private: - PRICENULL m_minPriceIncrement; +private: + PRICENULL m_minPriceIncrement; - public: - SBE_NODISCARD PRICENULL &minPriceIncrement() { - m_minPriceIncrement.wrap( - m_buffer, m_offset + 111, m_actingVersion, m_bufferLength); - return m_minPriceIncrement; - } +public: + SBE_NODISCARD PRICENULL &minPriceIncrement() + { + m_minPriceIncrement.wrap(m_buffer, m_offset + 111, m_actingVersion, m_bufferLength); + return m_minPriceIncrement; + } - SBE_NODISCARD static const char *MinPriceIncrementAmountMetaAttribute( - 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 *MinPriceIncrementAmountMetaAttribute(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 minPriceIncrementAmountId() SBE_NOEXCEPT { - return 1146; - } + static SBE_CONSTEXPR std::uint16_t minPriceIncrementAmountId() SBE_NOEXCEPT + { + return 1146; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minPriceIncrementAmountSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minPriceIncrementAmountSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minPriceIncrementAmountInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minPriceIncrementAmountInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minPriceIncrementAmountSinceVersion(); + return m_actingVersion >= minPriceIncrementAmountSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minPriceIncrementAmountEncodingOffset() SBE_NOEXCEPT { - return 119; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minPriceIncrementAmountEncodingOffset() SBE_NOEXCEPT + { + return 119; + } - private: - PRICENULL m_minPriceIncrementAmount; +private: + PRICENULL m_minPriceIncrementAmount; - public: - SBE_NODISCARD PRICENULL &minPriceIncrementAmount() { - m_minPriceIncrementAmount.wrap( - m_buffer, m_offset + 119, m_actingVersion, m_bufferLength); - return m_minPriceIncrementAmount; - } +public: + SBE_NODISCARD PRICENULL &minPriceIncrementAmount() + { + m_minPriceIncrementAmount.wrap(m_buffer, m_offset + 119, m_actingVersion, m_bufferLength); + return m_minPriceIncrementAmount; + } - SBE_NODISCARD static const char * - DisplayFactorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "float"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DisplayFactorMetaAttribute(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 displayFactorId() SBE_NOEXCEPT { - return 9787; - } + static SBE_CONSTEXPR std::uint16_t displayFactorId() SBE_NOEXCEPT + { + return 9787; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - displayFactorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t displayFactorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool displayFactorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool displayFactorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= displayFactorSinceVersion(); + return m_actingVersion >= displayFactorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - displayFactorEncodingOffset() SBE_NOEXCEPT { - return 127; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t displayFactorEncodingOffset() SBE_NOEXCEPT + { + return 127; + } - private: - FLOAT m_displayFactor; +private: + FLOAT m_displayFactor; - public: - SBE_NODISCARD FLOAT &displayFactor() { - m_displayFactor.wrap( - m_buffer, m_offset + 127, m_actingVersion, m_bufferLength); - return m_displayFactor; - } +public: + SBE_NODISCARD FLOAT &displayFactor() + { + m_displayFactor.wrap(m_buffer, m_offset + 127, m_actingVersion, m_bufferLength); + return m_displayFactor; + } - SBE_NODISCARD static const char * - TickRuleMetaAttribute(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 *TickRuleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t tickRuleId() SBE_NOEXCEPT { return 6350; } + static SBE_CONSTEXPR std::uint16_t tickRuleId() SBE_NOEXCEPT + { + return 6350; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tickRuleSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tickRuleSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool tickRuleInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tickRuleInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tickRuleSinceVersion(); + return m_actingVersion >= tickRuleSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tickRuleEncodingOffset() SBE_NOEXCEPT { - return 135; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tickRuleEncodingOffset() SBE_NOEXCEPT + { + return 135; + } - static SBE_CONSTEXPR std::int8_t tickRuleNullValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t tickRuleNullValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::int8_t tickRuleMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } + static SBE_CONSTEXPR std::int8_t tickRuleMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } - static SBE_CONSTEXPR std::int8_t tickRuleMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t tickRuleMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::size_t tickRuleEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t tickRuleEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::int8_t tickRule() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 135, sizeof(std::int8_t)); - return (val); - } + SBE_NODISCARD std::int8_t tickRule() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 135, sizeof(std::int8_t)); + return (val); + } - MDInstrumentDefinitionOption41 & - tickRule(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 135, &val, sizeof(std::int8_t)); - return *this; - } + MDInstrumentDefinitionOption41 &tickRule(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 135, &val, sizeof(std::int8_t)); + return *this; + } - SBE_NODISCARD static const char * - MainFractionMetaAttribute(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 *MainFractionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mainFractionId() SBE_NOEXCEPT { - return 37702; - } + static SBE_CONSTEXPR std::uint16_t mainFractionId() SBE_NOEXCEPT + { + return 37702; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mainFractionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mainFractionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mainFractionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mainFractionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mainFractionSinceVersion(); + return m_actingVersion >= mainFractionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mainFractionEncodingOffset() SBE_NOEXCEPT { - return 136; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mainFractionEncodingOffset() SBE_NOEXCEPT + { + return 136; + } - static SBE_CONSTEXPR std::uint8_t mainFractionNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t mainFractionNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t mainFractionMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t mainFractionMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t mainFractionMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t mainFractionMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t mainFractionEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t mainFractionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t mainFraction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 136, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t mainFraction() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 136, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionOption41 & - mainFraction(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 136, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionOption41 &mainFraction(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 136, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - SubFractionMetaAttribute(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 *SubFractionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t subFractionId() SBE_NOEXCEPT { - return 37703; - } + static SBE_CONSTEXPR std::uint16_t subFractionId() SBE_NOEXCEPT + { + return 37703; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - subFractionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t subFractionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool subFractionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool subFractionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= subFractionSinceVersion(); + return m_actingVersion >= subFractionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - subFractionEncodingOffset() SBE_NOEXCEPT { - return 137; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t subFractionEncodingOffset() SBE_NOEXCEPT + { + return 137; + } - static SBE_CONSTEXPR std::uint8_t subFractionNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t subFractionNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t subFractionMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t subFractionMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t subFractionMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t subFractionMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t subFractionEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t subFractionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t subFraction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 137, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t subFraction() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 137, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionOption41 & - subFraction(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 137, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionOption41 &subFraction(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 137, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char *PriceDisplayFormatMetaAttribute( - 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 *PriceDisplayFormatMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t priceDisplayFormatId() SBE_NOEXCEPT { - return 9800; - } + static SBE_CONSTEXPR std::uint16_t priceDisplayFormatId() SBE_NOEXCEPT + { + return 9800; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceDisplayFormatSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceDisplayFormatSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool priceDisplayFormatInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool priceDisplayFormatInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= priceDisplayFormatSinceVersion(); + return m_actingVersion >= priceDisplayFormatSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceDisplayFormatEncodingOffset() SBE_NOEXCEPT { - return 138; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceDisplayFormatEncodingOffset() SBE_NOEXCEPT + { + return 138; + } - static SBE_CONSTEXPR std::uint8_t - priceDisplayFormatNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t priceDisplayFormatNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - priceDisplayFormatEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t priceDisplayFormatEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t priceDisplayFormat() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 138, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t priceDisplayFormat() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 138, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionOption41 & - priceDisplayFormat(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 138, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionOption41 &priceDisplayFormat(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 138, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - UnitOfMeasureMetaAttribute(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 *UnitOfMeasureMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t unitOfMeasureId() SBE_NOEXCEPT { - return 996; - } + static SBE_CONSTEXPR std::uint16_t unitOfMeasureId() SBE_NOEXCEPT + { + return 996; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - unitOfMeasureSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t unitOfMeasureSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool unitOfMeasureInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool unitOfMeasureInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= unitOfMeasureSinceVersion(); + return m_actingVersion >= unitOfMeasureSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - unitOfMeasureEncodingOffset() SBE_NOEXCEPT { - return 139; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t unitOfMeasureEncodingOffset() SBE_NOEXCEPT + { + return 139; + } - static SBE_CONSTEXPR char unitOfMeasureNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char unitOfMeasureNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char unitOfMeasureMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char unitOfMeasureMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char unitOfMeasureMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char unitOfMeasureMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t unitOfMeasureEncodingLength() SBE_NOEXCEPT { - return 30; - } + static SBE_CONSTEXPR std::size_t unitOfMeasureEncodingLength() SBE_NOEXCEPT + { + return 30; + } - static SBE_CONSTEXPR std::uint64_t unitOfMeasureLength() SBE_NOEXCEPT { - return 30; - } + static SBE_CONSTEXPR std::uint64_t unitOfMeasureLength() SBE_NOEXCEPT + { + return 30; + } - SBE_NODISCARD const char *unitOfMeasure() const SBE_NOEXCEPT { - return m_buffer + m_offset + 139; - } + SBE_NODISCARD const char *unitOfMeasure() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 139; + } - SBE_NODISCARD char *unitOfMeasure() SBE_NOEXCEPT { - return m_buffer + m_offset + 139; - } + SBE_NODISCARD char *unitOfMeasure() SBE_NOEXCEPT + { + return m_buffer + m_offset + 139; + } - SBE_NODISCARD char unitOfMeasure(const std::uint64_t index) const { - if (index >= 30) { - throw std::runtime_error( - "index out of range for unitOfMeasure [E104]"); - } + SBE_NODISCARD char unitOfMeasure(const std::uint64_t index) const + { + if (index >= 30) + { + throw std::runtime_error("index out of range for unitOfMeasure [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 139 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 139 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption41 & - unitOfMeasure(const std::uint64_t index, const char value) { - if (index >= 30) { - throw std::runtime_error( - "index out of range for unitOfMeasure [E105]"); - } + MDInstrumentDefinitionOption41 &unitOfMeasure(const std::uint64_t index, const char value) + { + if (index >= 30) + { + throw std::runtime_error("index out of range for unitOfMeasure [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 139 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 139 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getUnitOfMeasure(char *const dst, const std::uint64_t length) const { - if (length > 30) { - throw std::runtime_error( - "length too large for getUnitOfMeasure [E106]"); - } + std::uint64_t getUnitOfMeasure(char *const dst, const std::uint64_t length) const + { + if (length > 30) + { + throw std::runtime_error("length too large for getUnitOfMeasure [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 139, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 139, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionOption41 & - putUnitOfMeasure(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 139, src, sizeof(char) * 30); - return *this; - } + MDInstrumentDefinitionOption41 &putUnitOfMeasure(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 139, src, sizeof(char) * 30); + return *this; + } - std::string getUnitOfMeasureAsString() const { - const char *buffer = m_buffer + m_offset + 139; - size_t length = 0; + SBE_NODISCARD std::string getUnitOfMeasureAsString() const + { + const char *buffer = m_buffer + m_offset + 139; + 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 getUnitOfMeasureAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getUnitOfMeasureAsString(); + std::string getUnitOfMeasureAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getUnitOfMeasureAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getUnitOfMeasureAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 139; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getUnitOfMeasureAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 139; + 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 - MDInstrumentDefinitionOption41 & - putUnitOfMeasure(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 30) { - throw std::runtime_error( - "string too large for putUnitOfMeasure [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionOption41 &putUnitOfMeasure(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 30) + { + throw std::runtime_error("string too large for putUnitOfMeasure [E106]"); + } - std::memcpy(m_buffer + m_offset + 139, str.data(), srcLength); - for (size_t start = srcLength; start < 30; ++start) { - m_buffer[m_offset + 139 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 139, str.data(), srcLength); + for (size_t start = srcLength; start < 30; ++start) + { + m_buffer[m_offset + 139 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption41 &putUnitOfMeasure(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 30) { - throw std::runtime_error( - "string too large for putUnitOfMeasure [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionOption41 &putUnitOfMeasure(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 30) + { + throw std::runtime_error("string too large for putUnitOfMeasure [E106]"); + } - std::memcpy(m_buffer + m_offset + 139, str.c_str(), srcLength); - for (size_t start = srcLength; start < 30; ++start) { - m_buffer[m_offset + 139 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 139, str.c_str(), srcLength); + for (size_t start = srcLength; start < 30; ++start) + { + m_buffer[m_offset + 139 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *UnitOfMeasureQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UnitOfMeasureQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t unitOfMeasureQtyId() SBE_NOEXCEPT { - return 1147; - } + static SBE_CONSTEXPR std::uint16_t unitOfMeasureQtyId() SBE_NOEXCEPT + { + return 1147; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - unitOfMeasureQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t unitOfMeasureQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool unitOfMeasureQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool unitOfMeasureQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= unitOfMeasureQtySinceVersion(); + return m_actingVersion >= unitOfMeasureQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - unitOfMeasureQtyEncodingOffset() SBE_NOEXCEPT { - return 169; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t unitOfMeasureQtyEncodingOffset() SBE_NOEXCEPT + { + return 169; + } - private: - PRICENULL m_unitOfMeasureQty; +private: + PRICENULL m_unitOfMeasureQty; - public: - SBE_NODISCARD PRICENULL &unitOfMeasureQty() { - m_unitOfMeasureQty.wrap( - m_buffer, m_offset + 169, m_actingVersion, m_bufferLength); - return m_unitOfMeasureQty; - } +public: + SBE_NODISCARD PRICENULL &unitOfMeasureQty() + { + m_unitOfMeasureQty.wrap(m_buffer, m_offset + 169, m_actingVersion, m_bufferLength); + return m_unitOfMeasureQty; + } - SBE_NODISCARD static const char *TradingReferencePriceMetaAttribute( - 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 *TradingReferencePriceMetaAttribute(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 tradingReferencePriceId() SBE_NOEXCEPT { - return 1150; - } + static SBE_CONSTEXPR std::uint16_t tradingReferencePriceId() SBE_NOEXCEPT + { + return 1150; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingReferencePriceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingReferencePriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool tradingReferencePriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tradingReferencePriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tradingReferencePriceSinceVersion(); + return m_actingVersion >= tradingReferencePriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingReferencePriceEncodingOffset() SBE_NOEXCEPT { - return 177; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingReferencePriceEncodingOffset() SBE_NOEXCEPT + { + return 177; + } - private: - PRICENULL m_tradingReferencePrice; +private: + PRICENULL m_tradingReferencePrice; - public: - SBE_NODISCARD PRICENULL &tradingReferencePrice() { - m_tradingReferencePrice.wrap( - m_buffer, m_offset + 177, m_actingVersion, m_bufferLength); - return m_tradingReferencePrice; - } +public: + SBE_NODISCARD PRICENULL &tradingReferencePrice() + { + m_tradingReferencePrice.wrap(m_buffer, m_offset + 177, m_actingVersion, m_bufferLength); + return m_tradingReferencePrice; + } - SBE_NODISCARD static const char * - SettlPriceTypeMetaAttribute(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 *SettlPriceTypeMetaAttribute(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 settlPriceTypeId() SBE_NOEXCEPT { - return 731; - } + static SBE_CONSTEXPR std::uint16_t settlPriceTypeId() SBE_NOEXCEPT + { + return 731; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - settlPriceTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t settlPriceTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= settlPriceTypeSinceVersion(); + return m_actingVersion >= settlPriceTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingOffset() SBE_NOEXCEPT { - return 185; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingOffset() SBE_NOEXCEPT + { + return 185; + } - private: - SettlPriceType m_settlPriceType; +private: + SettlPriceType m_settlPriceType; - public: - SBE_NODISCARD SettlPriceType &settlPriceType() { - m_settlPriceType.wrap( - m_buffer, m_offset + 185, m_actingVersion, m_bufferLength); - return m_settlPriceType; - } +public: + SBE_NODISCARD SettlPriceType &settlPriceType() + { + m_settlPriceType.wrap(m_buffer, m_offset + 185, m_actingVersion, m_bufferLength); + return m_settlPriceType; + } - static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char * - ClearedVolumeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ClearedVolumeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t clearedVolumeId() SBE_NOEXCEPT { - return 5791; - } + static SBE_CONSTEXPR std::uint16_t clearedVolumeId() SBE_NOEXCEPT + { + return 5791; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clearedVolumeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clearedVolumeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool clearedVolumeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool clearedVolumeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clearedVolumeSinceVersion(); + return m_actingVersion >= clearedVolumeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clearedVolumeEncodingOffset() SBE_NOEXCEPT { - return 186; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clearedVolumeEncodingOffset() SBE_NOEXCEPT + { + return 186; + } - static SBE_CONSTEXPR std::int32_t clearedVolumeNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t clearedVolumeNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t clearedVolumeMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t clearedVolumeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t clearedVolumeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t clearedVolumeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t clearedVolumeEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t clearedVolumeEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t clearedVolume() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 186, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t clearedVolume() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 186, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionOption41 & - clearedVolume(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 186, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionOption41 &clearedVolume(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 186, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char *OpenInterestQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OpenInterestQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t openInterestQtyId() SBE_NOEXCEPT { - return 5792; - } + static SBE_CONSTEXPR std::uint16_t openInterestQtyId() SBE_NOEXCEPT + { + return 5792; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - openInterestQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t openInterestQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool openInterestQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool openInterestQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= openInterestQtySinceVersion(); + return m_actingVersion >= openInterestQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - openInterestQtyEncodingOffset() SBE_NOEXCEPT { - return 190; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t openInterestQtyEncodingOffset() SBE_NOEXCEPT + { + return 190; + } - static SBE_CONSTEXPR std::int32_t openInterestQtyNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t openInterestQtyNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t openInterestQtyMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t openInterestQtyMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t openInterestQtyMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t openInterestQtyMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t - openInterestQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t openInterestQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t openInterestQty() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 190, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t openInterestQty() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 190, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionOption41 & - openInterestQty(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 190, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionOption41 &openInterestQty(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 190, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - LowLimitPriceMetaAttribute(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 *LowLimitPriceMetaAttribute(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 lowLimitPriceId() SBE_NOEXCEPT { - return 1148; - } + static SBE_CONSTEXPR std::uint16_t lowLimitPriceId() SBE_NOEXCEPT + { + return 1148; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lowLimitPriceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lowLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lowLimitPriceSinceVersion(); + return m_actingVersion >= lowLimitPriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lowLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 194; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lowLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 194; + } - private: - PRICENULL m_lowLimitPrice; +private: + PRICENULL m_lowLimitPrice; - public: - SBE_NODISCARD PRICENULL &lowLimitPrice() { - m_lowLimitPrice.wrap( - m_buffer, m_offset + 194, m_actingVersion, m_bufferLength); - return m_lowLimitPrice; - } +public: + SBE_NODISCARD PRICENULL &lowLimitPrice() + { + m_lowLimitPrice.wrap(m_buffer, m_offset + 194, m_actingVersion, m_bufferLength); + return m_lowLimitPrice; + } - SBE_NODISCARD static const char * - HighLimitPriceMetaAttribute(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 *HighLimitPriceMetaAttribute(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 highLimitPriceId() SBE_NOEXCEPT { - return 1149; - } + static SBE_CONSTEXPR std::uint16_t highLimitPriceId() SBE_NOEXCEPT + { + return 1149; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - highLimitPriceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t highLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= highLimitPriceSinceVersion(); + return m_actingVersion >= highLimitPriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - highLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 202; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t highLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 202; + } - private: - PRICENULL m_highLimitPrice; +private: + PRICENULL m_highLimitPrice; - public: - SBE_NODISCARD PRICENULL &highLimitPrice() { - m_highLimitPrice.wrap( - m_buffer, m_offset + 202, m_actingVersion, m_bufferLength); - return m_highLimitPrice; - } +public: + SBE_NODISCARD PRICENULL &highLimitPrice() + { + m_highLimitPrice.wrap(m_buffer, m_offset + 202, m_actingVersion, m_bufferLength); + return m_highLimitPrice; + } - SBE_NODISCARD static const char *UserDefinedInstrumentMetaAttribute( - 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 *UserDefinedInstrumentMetaAttribute(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 userDefinedInstrumentId() SBE_NOEXCEPT { - return 9779; - } + 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 static SBE_CONSTEXPR std::uint64_t userDefinedInstrumentSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool userDefinedInstrumentInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool userDefinedInstrumentInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= userDefinedInstrumentSinceVersion(); + return m_actingVersion >= userDefinedInstrumentSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - userDefinedInstrumentEncodingOffset() SBE_NOEXCEPT { - return 210; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t userDefinedInstrumentEncodingOffset() SBE_NOEXCEPT + { + return 210; + } - static SBE_CONSTEXPR char userDefinedInstrumentNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char userDefinedInstrumentNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char userDefinedInstrumentMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char userDefinedInstrumentMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char userDefinedInstrumentMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char userDefinedInstrumentMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - userDefinedInstrumentEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t userDefinedInstrumentEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD char userDefinedInstrument() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 210, sizeof(char)); - return (val); - } + SBE_NODISCARD char userDefinedInstrument() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 210, sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption41 & - userDefinedInstrument(const char value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 210, &val, sizeof(char)); - return *this; - } + MDInstrumentDefinitionOption41 &userDefinedInstrument(const char value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 210, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char *TradingReferenceDateMetaAttribute( - 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 *TradingReferenceDateMetaAttribute(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 tradingReferenceDateId() SBE_NOEXCEPT { - return 5796; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateId() SBE_NOEXCEPT + { + return 5796; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingReferenceDateSinceVersion() SBE_NOEXCEPT { - return 6; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingReferenceDateSinceVersion() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tradingReferenceDateSinceVersion(); + return m_actingVersion >= tradingReferenceDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingOffset() SBE_NOEXCEPT { - return 211; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingOffset() SBE_NOEXCEPT + { + return 211; + } - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t tradingReferenceDate() const SBE_NOEXCEPT { - if (m_actingVersion < 6) { - return (std::uint16_t)65535; - } + SBE_NODISCARD std::uint16_t tradingReferenceDate() const SBE_NOEXCEPT + { + if (m_actingVersion < 6) + { + return static_cast(65535); + } - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 211, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 211, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - MDInstrumentDefinitionOption41 & - tradingReferenceDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 211, &val, sizeof(std::uint16_t)); - return *this; - } + MDInstrumentDefinitionOption41 &tradingReferenceDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 211, &val, sizeof(std::uint16_t)); + return *this; + } - class NoEvents { + class NoEvents + { 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 NoEvents &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(static_cast(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 *EventTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t eventTypeId() SBE_NOEXCEPT + { + return 865; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t eventTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool eventTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= eventTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t eventTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t eventTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD EventType::Value eventType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint8_t)); + return EventType::get((val)); + } + + NoEvents &eventType(const EventType::Value 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 *EventTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t eventTimeId() SBE_NOEXCEPT + { + return 1145; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t eventTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool eventTimeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= eventTimeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t eventTimeEncodingOffset() SBE_NOEXCEPT + { + return 1; + } + + static SBE_CONSTEXPR std::uint64_t eventTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t eventTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t eventTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t eventTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t eventTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoEvents &eventTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint64_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoEvents writer) + { + builder << '{'; + builder << R"("EventType": )"; + builder << '"' << writer.eventType() << '"'; + + builder << ", "; + builder << R"("EventTime": )"; + builder << +writer.eventTime(); + + 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: + NoEvents m_noEvents; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 9; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoEventsId() SBE_NOEXCEPT + { + return 864; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoEvents &noEvents() + { + m_noEvents.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noEvents; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoEvents &noEventsCount(const std::uint8_t count) + { + m_noEvents.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noEvents; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noEventsSinceVersion() 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 NoEvents &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 * - EventTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t eventTypeId() SBE_NOEXCEPT { - return 865; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - eventTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool eventTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noEventsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= eventTypeSinceVersion(); + return m_actingVersion >= noEventsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - eventTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - eventTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD EventType::Value eventType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint8_t)); - return EventType::get((val)); - } - - NoEvents &eventType(const EventType::Value 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 * - EventTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t eventTimeId() SBE_NOEXCEPT { - return 1145; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - eventTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool eventTimeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= eventTimeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - eventTimeEncodingOffset() SBE_NOEXCEPT { - return 1; - } - - static SBE_CONSTEXPR std::uint64_t eventTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t eventTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t eventTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t eventTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t eventTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoEvents &eventTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint64_t)); - return *this; - } - - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoEvents writer) { - builder << '{'; - builder << R"("EventType": )"; - builder << '"' << writer.eventType() << '"'; - - builder << ", "; - builder << R"("EventTime": )"; - builder << +writer.eventTime(); - - builder << '}'; - - return builder; - } - }; - - private: - NoEvents m_noEvents; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoEventsId() SBE_NOEXCEPT { - return 864; - } - - SBE_NODISCARD inline NoEvents &noEvents() { - m_noEvents.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noEvents; - } - - NoEvents &noEventsCount(const std::uint8_t count) { - m_noEvents.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noEvents; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noEventsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noEventsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noEventsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoMDFeedTypes { + class NoMDFeedTypes + { 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(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; + } + + 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 NoMDFeedTypes &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(static_cast(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 *MDFeedTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDFeedTypeId() SBE_NOEXCEPT + { + return 1022; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDFeedTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDFeedTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDFeedTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDFeedTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR char mDFeedTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char mDFeedTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char mDFeedTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t mDFeedTypeEncodingLength() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t mDFeedTypeLength() SBE_NOEXCEPT + { + return 3; + } + + SBE_NODISCARD const char *mDFeedType() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } + + SBE_NODISCARD char *mDFeedType() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } + + SBE_NODISCARD char mDFeedType(const std::uint64_t index) const + { + if (index >= 3) + { + throw std::runtime_error("index out of range for mDFeedType [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } + + NoMDFeedTypes &mDFeedType(const std::uint64_t index, const char value) + { + if (index >= 3) + { + throw std::runtime_error("index out of range for mDFeedType [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getMDFeedType(char *const dst, const std::uint64_t length) const + { + if (length > 3) + { + throw std::runtime_error("length too large for getMDFeedType [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } + + NoMDFeedTypes &putMDFeedType(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 3); + return *this; + } + + NoMDFeedTypes &putMDFeedType( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 0, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 1, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 2, &val2, sizeof(char)); + + return *this; + } + + SBE_NODISCARD std::string getMDFeedTypeAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + size_t length = 0; + + for (; length < 3 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getMDFeedTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getMDFeedTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + 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 getMDFeedTypeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + size_t length = 0; + + for (; length < 3 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoMDFeedTypes &putMDFeedType(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putMDFeedType [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #else + NoMDFeedTypes &putMDFeedType(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putMDFeedType [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *MarketDepthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t marketDepthId() SBE_NOEXCEPT + { + return 264; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t marketDepthSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool marketDepthInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= marketDepthSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t marketDepthEncodingOffset() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::int8_t marketDepthNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t marketDepthMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t marketDepthMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t marketDepthEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::int8_t marketDepth() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 3, sizeof(std::int8_t)); + return (val); + } + + NoMDFeedTypes &marketDepth(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 3, &val, sizeof(std::int8_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDFeedTypes writer) + { + builder << '{'; + builder << R"("MDFeedType": )"; + builder << '"' << + writer.getMDFeedTypeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("MarketDepth": )"; + builder << +writer.marketDepth(); + + 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)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; - } +private: + NoMDFeedTypes m_noMDFeedTypes; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 4; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDFeedTypesId() SBE_NOEXCEPT + { + return 1141; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDFeedTypes &noMDFeedTypes() + { + m_noMDFeedTypes.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDFeedTypes; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDFeedTypes &noMDFeedTypesCount(const std::uint8_t count) + { + m_noMDFeedTypes.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDFeedTypes; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDFeedTypesSinceVersion() 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 NoMDFeedTypes &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 * - MDFeedTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDFeedTypeId() SBE_NOEXCEPT { - return 1022; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDFeedTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDFeedTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noMDFeedTypesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDFeedTypeSinceVersion(); + return m_actingVersion >= noMDFeedTypesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDFeedTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR char mDFeedTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char mDFeedTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char mDFeedTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t mDFeedTypeEncodingLength() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t mDFeedTypeLength() SBE_NOEXCEPT { - return 3; - } - - SBE_NODISCARD const char *mDFeedType() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char *mDFeedType() SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char mDFeedType(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error( - "index out of range for mDFeedType [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } - - NoMDFeedTypes &mDFeedType(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error( - "index out of range for mDFeedType [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getMDFeedType(char *const dst, const std::uint64_t length) const { - if (length > 3) { - throw std::runtime_error( - "length too large for getMDFeedType [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } - - NoMDFeedTypes &putMDFeedType(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 3); - return *this; - } - - NoMDFeedTypes & - putMDFeedType(const char value0, const char value1, const char value2) - SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 0, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 1, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 2, &val2, sizeof(char)); - - return *this; - } - - std::string getMDFeedTypeAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 3 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getMDFeedTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getMDFeedTypeAsString(); - - 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 getMDFeedTypeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 3 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - NoMDFeedTypes &putMDFeedType(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putMDFeedType [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#else - NoMDFeedTypes &putMDFeedType(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putMDFeedType [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - MarketDepthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t marketDepthId() SBE_NOEXCEPT { - return 264; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - marketDepthSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool marketDepthInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= marketDepthSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - marketDepthEncodingOffset() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::int8_t marketDepthNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t marketDepthMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t marketDepthMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t - marketDepthEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::int8_t marketDepth() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 3, sizeof(std::int8_t)); - return (val); - } - - NoMDFeedTypes &marketDepth(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 3, &val, sizeof(std::int8_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDFeedTypes writer) { - builder << '{'; - builder << R"("MDFeedType": )"; - builder << '"' << writer.getMDFeedTypeAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("MarketDepth": )"; - builder << +writer.marketDepth(); - - builder << '}'; - - return builder; - } - }; - - private: - NoMDFeedTypes m_noMDFeedTypes; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDFeedTypesId() SBE_NOEXCEPT { - return 1141; - } - - SBE_NODISCARD inline NoMDFeedTypes &noMDFeedTypes() { - m_noMDFeedTypes.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDFeedTypes; - } - - NoMDFeedTypes &noMDFeedTypesCount(const std::uint8_t count) { - m_noMDFeedTypes.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDFeedTypes; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDFeedTypesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDFeedTypesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDFeedTypesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoInstAttrib { + class NoInstAttrib + { 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(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; + } + + 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 NoInstAttrib &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(static_cast(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 *InstAttribTypeMetaAttribute(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 instAttribTypeId() SBE_NOEXCEPT + { + return 871; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t instAttribTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool instAttribTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= instAttribTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t instAttribTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::int8_t instAttribTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t instAttribTypeMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t instAttribTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t instAttribTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::int8_t instAttribType() SBE_NOEXCEPT + { + return static_cast(24); + } + + SBE_NODISCARD static const char *InstAttribValueMetaAttribute(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 instAttribValueId() SBE_NOEXCEPT + { + return 872; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t instAttribValueSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool instAttribValueInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= instAttribValueSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t instAttribValueEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + private: + InstAttribValue m_instAttribValue; + + public: + SBE_NODISCARD InstAttribValue &instAttribValue() + { + m_instAttribValue.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_instAttribValue; + } + + static SBE_CONSTEXPR std::size_t instAttribValueEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoInstAttrib writer) + { + builder << '{'; + builder << R"("InstAttribValue": )"; + builder << writer.instAttribValue(); + + 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)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; - } +private: + NoInstAttrib m_noInstAttrib; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 4; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoInstAttribId() SBE_NOEXCEPT + { + return 870; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoInstAttrib &noInstAttrib() + { + m_noInstAttrib.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noInstAttrib; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoInstAttrib &noInstAttribCount(const std::uint8_t count) + { + m_noInstAttrib.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noInstAttrib; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noInstAttribSinceVersion() 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 NoInstAttrib &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 *InstAttribTypeMetaAttribute( - 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 instAttribTypeId() SBE_NOEXCEPT { - return 871; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - instAttribTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool instAttribTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noInstAttribInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= instAttribTypeSinceVersion(); + return m_actingVersion >= noInstAttribSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - instAttribTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int8_t instAttribTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t instAttribTypeMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t instAttribTypeMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t - instAttribTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::int8_t - instAttribType() SBE_NOEXCEPT { - return (std::int8_t)24; - } - - SBE_NODISCARD static const char *InstAttribValueMetaAttribute( - 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 instAttribValueId() SBE_NOEXCEPT { - return 872; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - instAttribValueSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool instAttribValueInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= instAttribValueSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - instAttribValueEncodingOffset() SBE_NOEXCEPT { - return 0; - } + } + class NoLotTypeRules + { private: - InstAttribValue m_instAttribValue; + 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 InstAttribValue &instAttribValue() { - m_instAttribValue.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_instAttribValue; - } + 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; + } - static SBE_CONSTEXPR std::size_t - instAttribValueEncodingLength() SBE_NOEXCEPT { - return 4; - } + 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(5)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 5; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoInstAttrib writer) { - builder << '{'; - builder << R"("InstAttribValue": )"; - builder << writer.instAttribValue(); + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } - builder << '}'; + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 5; + } - return builder; - } - }; + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - private: - NoInstAttrib m_noInstAttrib; + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoInstAttribId() SBE_NOEXCEPT { - return 870; - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - SBE_NODISCARD inline NoInstAttrib &noInstAttrib() { - m_noInstAttrib.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noInstAttrib; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - NoInstAttrib &noInstAttribCount(const std::uint8_t count) { - m_noInstAttrib.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noInstAttrib; - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noInstAttribSinceVersion() SBE_NOEXCEPT { - return 0; - } + inline NoLotTypeRules &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 bool noInstAttribInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noInstAttribSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + return *this; + } - class NoLotTypeRules { - 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; + inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT + { + 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 std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + #if __cplusplus < 201103L + template inline void forEach(Func& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - 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; - } + #else + template inline void forEach(Func&& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + #endif + + SBE_NODISCARD static const char *LotTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lotTypeId() SBE_NOEXCEPT + { + return 1093; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lotTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lotTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= lotTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lotTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::int8_t lotTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t lotTypeMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t lotTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t lotTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::int8_t lotType() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int8_t)); + return (val); + } + + NoLotTypeRules &lotType(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int8_t)); + return *this; + } + + SBE_NODISCARD static const char *MinLotSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t minLotSizeId() SBE_NOEXCEPT + { + return 1231; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minLotSizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool minLotSizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= minLotSizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minLotSizeEncodingOffset() SBE_NOEXCEPT + { + return 1; + } + +private: + DecimalQty m_minLotSize; + +public: + SBE_NODISCARD DecimalQty &minLotSize() + { + m_minLotSize.wrap(m_buffer, m_offset + 1, m_actingVersion, m_bufferLength); + return m_minLotSize; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoLotTypeRules writer) + { + builder << '{'; + builder << R"("LotType": )"; + builder << +writer.lotType(); + + builder << ", "; + builder << R"("MinLotSize": )"; + builder << writer.minLotSize(); + + 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)5); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 5; - 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: + NoLotTypeRules m_noLotTypeRules; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 5; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoLotTypeRulesId() SBE_NOEXCEPT + { + return 1234; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoLotTypeRules &noLotTypeRules() + { + m_noLotTypeRules.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLotTypeRules; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoLotTypeRules &noLotTypeRulesCount(const std::uint8_t count) + { + m_noLotTypeRules.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLotTypeRules; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noLotTypeRulesSinceVersion() 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 NoLotTypeRules &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 * - LotTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t lotTypeId() SBE_NOEXCEPT { - return 1093; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lotTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lotTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noLotTypeRulesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lotTypeSinceVersion(); + return m_actingVersion >= noLotTypeRulesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lotTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int8_t lotTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t lotTypeMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t lotTypeMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t lotTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::int8_t lotType() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int8_t)); - return (val); - } - - NoLotTypeRules &lotType(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int8_t)); - return *this; - } - - SBE_NODISCARD static const char * - MinLotSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t minLotSizeId() SBE_NOEXCEPT { - return 1231; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minLotSizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool minLotSizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= minLotSizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minLotSizeEncodingOffset() SBE_NOEXCEPT { - return 1; - } + } + class NoUnderlyings + { private: - DecimalQty m_minLotSize; + 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 DecimalQty &minLotSize() { - m_minLotSize.wrap( - m_buffer, m_offset + 1, m_actingVersion, m_bufferLength); - return m_minLotSize; - } + 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; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoLotTypeRules writer) { - builder << '{'; - builder << R"("LotType": )"; - builder << +writer.lotType(); + 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(24)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 24; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - builder << ", "; - builder << R"("MinLotSize": )"; - builder << writer.minLotSize(); + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } - builder << '}'; + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 24; + } - return builder; - } - }; + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - private: - NoLotTypeRules m_noLotTypeRules; + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoLotTypeRulesId() SBE_NOEXCEPT { - return 1234; - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - SBE_NODISCARD inline NoLotTypeRules &noLotTypeRules() { - m_noLotTypeRules.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLotTypeRules; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - NoLotTypeRules &noLotTypeRulesCount(const std::uint8_t count) { - m_noLotTypeRules.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLotTypeRules; - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noLotTypeRulesSinceVersion() SBE_NOEXCEPT { - return 0; - } + inline NoUnderlyings &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 bool noLotTypeRulesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noLotTypeRulesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + return *this; + } - class NoUnderlyings { - 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; + inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT + { + 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 std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + #if __cplusplus < 201103L + template inline void forEach(Func& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - 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; - } + #else + template inline void forEach(Func&& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + #endif + + SBE_NODISCARD static const char *UnderlyingSecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + 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 0; + } + + static SBE_CONSTEXPR std::int32_t underlyingSecurityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + 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 + 0, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoUnderlyings &underlyingSecurityID(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 *UnderlyingSecurityIDSourceMetaAttribute(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 underlyingSecurityIDSourceId() SBE_NOEXCEPT + { + return 305; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t underlyingSecurityIDSourceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool underlyingSecurityIDSourceInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= underlyingSecurityIDSourceSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t underlyingSecurityIDSourceEncodingOffset() SBE_NOEXCEPT + { + return 4; + } + + static SBE_CONSTEXPR char underlyingSecurityIDSourceNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char underlyingSecurityIDSourceMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char underlyingSecurityIDSourceMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t underlyingSecurityIDSourceEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t underlyingSecurityIDSourceLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *underlyingSecurityIDSource() const + { + static const std::uint8_t underlyingSecurityIDSourceValues[] = { 56 }; + + return (const char *)underlyingSecurityIDSourceValues; + } + + SBE_NODISCARD char underlyingSecurityIDSource(const std::uint64_t index) const + { + static const std::uint8_t underlyingSecurityIDSourceValues[] = { 56 }; + + return (char)underlyingSecurityIDSourceValues[index]; + } + + std::uint64_t getUnderlyingSecurityIDSource(char *dst, const std::uint64_t length) const + { + static std::uint8_t underlyingSecurityIDSourceValues[] = { 56 }; + std::uint64_t bytesToCopy = length < sizeof(underlyingSecurityIDSourceValues) ? length : sizeof(underlyingSecurityIDSourceValues); + + std::memcpy(dst, underlyingSecurityIDSourceValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getUnderlyingSecurityIDSourceAsString() const + { + static const std::uint8_t UnderlyingSecurityIDSourceValues[] = { 56 }; + + return std::string((const char *)UnderlyingSecurityIDSourceValues, 1); + } + + std::string getUnderlyingSecurityIDSourceAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getUnderlyingSecurityIDSourceAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + 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 *UnderlyingSymbolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t underlyingSymbolId() SBE_NOEXCEPT + { + return 311; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t underlyingSymbolSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool underlyingSymbolInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= underlyingSymbolSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t underlyingSymbolEncodingOffset() SBE_NOEXCEPT + { + return 4; + } + + static SBE_CONSTEXPR char underlyingSymbolNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char underlyingSymbolMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char underlyingSymbolMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t underlyingSymbolEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t underlyingSymbolLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *underlyingSymbol() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 4; + } + + SBE_NODISCARD char *underlyingSymbol() SBE_NOEXCEPT + { + return m_buffer + m_offset + 4; + } + + SBE_NODISCARD char underlyingSymbol(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for underlyingSymbol [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 4 + (index * 1), sizeof(char)); + return (val); + } + + NoUnderlyings &underlyingSymbol(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for underlyingSymbol [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 4 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getUnderlyingSymbol(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getUnderlyingSymbol [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 4, sizeof(char) * static_cast(length)); + return length; + } + + NoUnderlyings &putUnderlyingSymbol(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 4, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getUnderlyingSymbolAsString() const + { + const char *buffer = m_buffer + m_offset + 4; + size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getUnderlyingSymbolAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getUnderlyingSymbolAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + 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 getUnderlyingSymbolAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 4; + size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoUnderlyings &putUnderlyingSymbol(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putUnderlyingSymbol [E106]"); + } + + std::memcpy(m_buffer + m_offset + 4, str.data(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 4 + start] = 0; + } + + return *this; + } + #else + NoUnderlyings &putUnderlyingSymbol(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putUnderlyingSymbol [E106]"); + } + + std::memcpy(m_buffer + m_offset + 4, str.c_str(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 4 + start] = 0; + } + + return *this; + } + #endif + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoUnderlyings writer) + { + builder << '{'; + builder << R"("UnderlyingSecurityID": )"; + builder << +writer.underlyingSecurityID(); + + builder << ", "; + builder << R"("UnderlyingSymbol": )"; + builder << '"' << + writer.getUnderlyingSymbolAsJsonEscapedString().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 - 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)24); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 24; - 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: + NoUnderlyings m_noUnderlyings; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 24; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoUnderlyingsId() SBE_NOEXCEPT + { + return 711; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoUnderlyings &noUnderlyings() + { + m_noUnderlyings.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noUnderlyings; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoUnderlyings &noUnderlyingsCount(const std::uint8_t count) + { + m_noUnderlyings.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noUnderlyings; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noUnderlyingsSinceVersion() 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 NoUnderlyings &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 *UnderlyingSecurityIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - 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 { + SBE_NODISCARD bool noUnderlyingsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= underlyingSecurityIDSinceVersion(); + return m_actingVersion >= noUnderlyingsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - underlyingSecurityIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int32_t - underlyingSecurityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - 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 + 0, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoUnderlyings & - underlyingSecurityID(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 *UnderlyingSecurityIDSourceMetaAttribute( - 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 - underlyingSecurityIDSourceId() SBE_NOEXCEPT { - return 305; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - underlyingSecurityIDSourceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool - underlyingSecurityIDSourceInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= underlyingSecurityIDSourceSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - underlyingSecurityIDSourceEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR char - underlyingSecurityIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char - underlyingSecurityIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char - underlyingSecurityIDSourceMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - underlyingSecurityIDSourceEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t - underlyingSecurityIDSourceLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *underlyingSecurityIDSource() const { - static const std::uint8_t underlyingSecurityIDSourceValues[] = {56}; - - return (const char *)underlyingSecurityIDSourceValues; - } - - SBE_NODISCARD char - underlyingSecurityIDSource(const std::uint64_t index) const { - static const std::uint8_t underlyingSecurityIDSourceValues[] = {56}; - - return (char)underlyingSecurityIDSourceValues[index]; - } - - std::uint64_t getUnderlyingSecurityIDSource( - char *dst, const std::uint64_t length) const { - static std::uint8_t underlyingSecurityIDSourceValues[] = {56}; - std::uint64_t bytesToCopy = - length < sizeof(underlyingSecurityIDSourceValues) - ? length - : sizeof(underlyingSecurityIDSourceValues); - - std::memcpy( - dst, underlyingSecurityIDSourceValues, - static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getUnderlyingSecurityIDSourceAsString() const { - static const std::uint8_t UnderlyingSecurityIDSourceValues[] = {56}; - - return std::string((const char *)UnderlyingSecurityIDSourceValues, 1); - } - - std::string getUnderlyingSecurityIDSourceAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getUnderlyingSecurityIDSourceAsString(); - - 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 *UnderlyingSymbolMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t underlyingSymbolId() SBE_NOEXCEPT { - return 311; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - underlyingSymbolSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool underlyingSymbolInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= underlyingSymbolSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - underlyingSymbolEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR char underlyingSymbolNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char underlyingSymbolMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char underlyingSymbolMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - underlyingSymbolEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t underlyingSymbolLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *underlyingSymbol() const SBE_NOEXCEPT { - return m_buffer + m_offset + 4; - } - - SBE_NODISCARD char *underlyingSymbol() SBE_NOEXCEPT { - return m_buffer + m_offset + 4; - } - - SBE_NODISCARD char underlyingSymbol(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error( - "index out of range for underlyingSymbol [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 4 + (index * 1), sizeof(char)); - return (val); - } - - NoUnderlyings & - underlyingSymbol(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error( - "index out of range for underlyingSymbol [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 4 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getUnderlyingSymbol(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error( - "length too large for getUnderlyingSymbol [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 4, - sizeof(char) * static_cast(length)); - return length; - } - - NoUnderlyings &putUnderlyingSymbol(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 4, src, sizeof(char) * 20); - return *this; - } - - std::string getUnderlyingSymbolAsString() const { - const char *buffer = m_buffer + m_offset + 4; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getUnderlyingSymbolAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getUnderlyingSymbolAsString(); - - 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 getUnderlyingSymbolAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 4; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - NoUnderlyings &putUnderlyingSymbol(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putUnderlyingSymbol [E106]"); - } - - std::memcpy(m_buffer + m_offset + 4, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 4 + start] = 0; - } - - return *this; - } -#else - NoUnderlyings &putUnderlyingSymbol(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putUnderlyingSymbol [E106]"); - } - - std::memcpy(m_buffer + m_offset + 4, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 4 + start] = 0; - } - - return *this; - } -#endif - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoUnderlyings writer) { - builder << '{'; - builder << R"("UnderlyingSecurityID": )"; - builder << +writer.underlyingSecurityID(); - - builder << ", "; - builder << R"("UnderlyingSymbol": )"; - builder << '"' - << writer.getUnderlyingSymbolAsJsonEscapedString().c_str() - << '"'; - - builder << '}'; - - return builder; - } - }; - - private: - NoUnderlyings m_noUnderlyings; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoUnderlyingsId() SBE_NOEXCEPT { - return 711; - } - - SBE_NODISCARD inline NoUnderlyings &noUnderlyings() { - m_noUnderlyings.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noUnderlyings; - } - - NoUnderlyings &noUnderlyingsCount(const std::uint8_t count) { - m_noUnderlyings.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noUnderlyings; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noUnderlyingsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noUnderlyingsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noUnderlyingsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoRelatedInstruments { + class NoRelatedInstruments + { 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(24)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 24; + 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 24; + } + + 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 NoRelatedInstruments &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(static_cast(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 *RelatedSecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t relatedSecurityIDId() SBE_NOEXCEPT + { + return 1650; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t relatedSecurityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool relatedSecurityIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= relatedSecurityIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t relatedSecurityIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::int32_t relatedSecurityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t relatedSecurityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t relatedSecurityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t relatedSecurityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t relatedSecurityID() 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); + } + + NoRelatedInstruments &relatedSecurityID(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 *RelatedSecurityIDSourceMetaAttribute(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 relatedSecurityIDSourceId() SBE_NOEXCEPT + { + return 1651; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t relatedSecurityIDSourceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool relatedSecurityIDSourceInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= relatedSecurityIDSourceSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t relatedSecurityIDSourceEncodingOffset() SBE_NOEXCEPT + { + return 4; + } + + static SBE_CONSTEXPR char relatedSecurityIDSourceNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char relatedSecurityIDSourceMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char relatedSecurityIDSourceMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t relatedSecurityIDSourceEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t relatedSecurityIDSourceLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *relatedSecurityIDSource() const + { + static const std::uint8_t relatedSecurityIDSourceValues[] = { 56 }; + + return (const char *)relatedSecurityIDSourceValues; + } + + SBE_NODISCARD char relatedSecurityIDSource(const std::uint64_t index) const + { + static const std::uint8_t relatedSecurityIDSourceValues[] = { 56 }; + + return (char)relatedSecurityIDSourceValues[index]; + } + + std::uint64_t getRelatedSecurityIDSource(char *dst, const std::uint64_t length) const + { + static std::uint8_t relatedSecurityIDSourceValues[] = { 56 }; + std::uint64_t bytesToCopy = length < sizeof(relatedSecurityIDSourceValues) ? length : sizeof(relatedSecurityIDSourceValues); + + std::memcpy(dst, relatedSecurityIDSourceValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getRelatedSecurityIDSourceAsString() const + { + static const std::uint8_t RelatedSecurityIDSourceValues[] = { 56 }; + + return std::string((const char *)RelatedSecurityIDSourceValues, 1); + } + + std::string getRelatedSecurityIDSourceAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getRelatedSecurityIDSourceAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + 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 *RelatedSymbolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t relatedSymbolId() SBE_NOEXCEPT + { + return 1649; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t relatedSymbolSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool relatedSymbolInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= relatedSymbolSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t relatedSymbolEncodingOffset() SBE_NOEXCEPT + { + return 4; + } + + static SBE_CONSTEXPR char relatedSymbolNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char relatedSymbolMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char relatedSymbolMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t relatedSymbolEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t relatedSymbolLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *relatedSymbol() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 4; + } + + SBE_NODISCARD char *relatedSymbol() SBE_NOEXCEPT + { + return m_buffer + m_offset + 4; + } + + SBE_NODISCARD char relatedSymbol(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for relatedSymbol [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 4 + (index * 1), sizeof(char)); + return (val); + } + + NoRelatedInstruments &relatedSymbol(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for relatedSymbol [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 4 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getRelatedSymbol(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getRelatedSymbol [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 4, sizeof(char) * static_cast(length)); + return length; + } + + NoRelatedInstruments &putRelatedSymbol(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 4, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getRelatedSymbolAsString() const + { + const char *buffer = m_buffer + m_offset + 4; + size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getRelatedSymbolAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getRelatedSymbolAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + 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 getRelatedSymbolAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 4; + size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoRelatedInstruments &putRelatedSymbol(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putRelatedSymbol [E106]"); + } + + std::memcpy(m_buffer + m_offset + 4, str.data(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 4 + start] = 0; + } + + return *this; + } + #else + NoRelatedInstruments &putRelatedSymbol(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putRelatedSymbol [E106]"); + } + + std::memcpy(m_buffer + m_offset + 4, str.c_str(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 4 + start] = 0; + } + + return *this; + } + #endif + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoRelatedInstruments writer) + { + builder << '{'; + builder << R"("RelatedSecurityID": )"; + builder << +writer.relatedSecurityID(); + + builder << ", "; + builder << R"("RelatedSymbol": )"; + builder << '"' << + writer.getRelatedSymbolAsJsonEscapedString().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 - 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)24); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 24; - 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: + NoRelatedInstruments m_noRelatedInstruments; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 24; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoRelatedInstrumentsId() SBE_NOEXCEPT + { + return 1647; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoRelatedInstruments &noRelatedInstruments() + { + m_noRelatedInstruments.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noRelatedInstruments; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoRelatedInstruments &noRelatedInstrumentsCount(const std::uint8_t count) + { + m_noRelatedInstruments.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noRelatedInstruments; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noRelatedInstrumentsSinceVersion() SBE_NOEXCEPT + { + return 7; + } - 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 NoRelatedInstruments &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 *RelatedSecurityIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t relatedSecurityIDId() SBE_NOEXCEPT { - return 1650; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - relatedSecurityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool relatedSecurityIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noRelatedInstrumentsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= relatedSecurityIDSinceVersion(); + return m_actingVersion >= noRelatedInstrumentsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - relatedSecurityIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int32_t - relatedSecurityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t - relatedSecurityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t - relatedSecurityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - relatedSecurityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t relatedSecurityID() 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); - } - - NoRelatedInstruments & - relatedSecurityID(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 *RelatedSecurityIDSourceMetaAttribute( - 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 - relatedSecurityIDSourceId() SBE_NOEXCEPT { - return 1651; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - relatedSecurityIDSourceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool relatedSecurityIDSourceInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= relatedSecurityIDSourceSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - relatedSecurityIDSourceEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR char - relatedSecurityIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char relatedSecurityIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char relatedSecurityIDSourceMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - relatedSecurityIDSourceEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t - relatedSecurityIDSourceLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *relatedSecurityIDSource() const { - static const std::uint8_t relatedSecurityIDSourceValues[] = {56}; - - return (const char *)relatedSecurityIDSourceValues; - } - - SBE_NODISCARD char - relatedSecurityIDSource(const std::uint64_t index) const { - static const std::uint8_t relatedSecurityIDSourceValues[] = {56}; - - return (char)relatedSecurityIDSourceValues[index]; - } - - std::uint64_t - getRelatedSecurityIDSource(char *dst, const std::uint64_t length) const { - static std::uint8_t relatedSecurityIDSourceValues[] = {56}; - std::uint64_t bytesToCopy = - length < sizeof(relatedSecurityIDSourceValues) - ? length - : sizeof(relatedSecurityIDSourceValues); - - std::memcpy( - dst, relatedSecurityIDSourceValues, - static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getRelatedSecurityIDSourceAsString() const { - static const std::uint8_t RelatedSecurityIDSourceValues[] = {56}; - - return std::string((const char *)RelatedSecurityIDSourceValues, 1); - } - - std::string getRelatedSecurityIDSourceAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getRelatedSecurityIDSourceAsString(); - - 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 *RelatedSymbolMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t relatedSymbolId() SBE_NOEXCEPT { - return 1649; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - relatedSymbolSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool relatedSymbolInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= relatedSymbolSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - relatedSymbolEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR char relatedSymbolNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char relatedSymbolMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char relatedSymbolMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - relatedSymbolEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t relatedSymbolLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *relatedSymbol() const SBE_NOEXCEPT { - return m_buffer + m_offset + 4; - } - - SBE_NODISCARD char *relatedSymbol() SBE_NOEXCEPT { - return m_buffer + m_offset + 4; - } - - SBE_NODISCARD char relatedSymbol(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error( - "index out of range for relatedSymbol [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 4 + (index * 1), sizeof(char)); - return (val); - } - - NoRelatedInstruments & - relatedSymbol(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error( - "index out of range for relatedSymbol [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 4 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getRelatedSymbol(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error( - "length too large for getRelatedSymbol [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 4, - sizeof(char) * static_cast(length)); - return length; - } - - NoRelatedInstruments & - putRelatedSymbol(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 4, src, sizeof(char) * 20); - return *this; - } - - std::string getRelatedSymbolAsString() const { - const char *buffer = m_buffer + m_offset + 4; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getRelatedSymbolAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getRelatedSymbolAsString(); - - 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 getRelatedSymbolAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 4; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - NoRelatedInstruments &putRelatedSymbol(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putRelatedSymbol [E106]"); - } - - std::memcpy(m_buffer + m_offset + 4, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 4 + start] = 0; - } - - return *this; - } -#else - NoRelatedInstruments &putRelatedSymbol(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putRelatedSymbol [E106]"); - } - - std::memcpy(m_buffer + m_offset + 4, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 4 + start] = 0; - } - - return *this; - } -#endif - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - NoRelatedInstruments writer) { - builder << '{'; - builder << R"("RelatedSecurityID": )"; - builder << +writer.relatedSecurityID(); - - builder << ", "; - builder << R"("RelatedSymbol": )"; - builder << '"' << writer.getRelatedSymbolAsJsonEscapedString().c_str() - << '"'; - - builder << '}'; - - return builder; - } - }; - - private: - NoRelatedInstruments m_noRelatedInstruments; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoRelatedInstrumentsId() SBE_NOEXCEPT { - return 1647; - } - - SBE_NODISCARD inline NoRelatedInstruments &noRelatedInstruments() { - m_noRelatedInstruments.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noRelatedInstruments; - } - - NoRelatedInstruments &noRelatedInstrumentsCount(const std::uint8_t count) { - m_noRelatedInstruments.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noRelatedInstruments; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noRelatedInstrumentsSinceVersion() SBE_NOEXCEPT { - return 7; - } - - SBE_NODISCARD bool noRelatedInstrumentsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noRelatedInstrumentsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDInstrumentDefinitionOption41 _writer) { - MDInstrumentDefinitionOption41 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDInstrumentDefinitionOption41", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); - - builder << ", "; - builder << R"("TotNumReports": )"; - builder << +writer.totNumReports(); - - builder << ", "; - builder << R"("SecurityUpdateAction": )"; - builder << '"' << writer.securityUpdateAction() << '"'; - - builder << ", "; - builder << R"("LastUpdateTime": )"; - builder << +writer.lastUpdateTime(); - - builder << ", "; - builder << R"("MDSecurityTradingStatus": )"; - builder << '"' << writer.mDSecurityTradingStatus() << '"'; - - builder << ", "; - builder << R"("ApplID": )"; - builder << +writer.applID(); - - builder << ", "; - builder << R"("MarketSegmentID": )"; - builder << +writer.marketSegmentID(); - - builder << ", "; - builder << R"("UnderlyingProduct": )"; - builder << +writer.underlyingProduct(); - - builder << ", "; - builder << R"("SecurityExchange": )"; - builder << '"' << writer.getSecurityExchangeAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("SecurityGroup": )"; - builder << '"' << writer.getSecurityGroupAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("Asset": )"; - builder << '"' << writer.getAssetAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("Symbol": )"; - builder << '"' << writer.getSymbolAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("SecurityType": )"; - builder << '"' << writer.getSecurityTypeAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("CFICode": )"; - builder << '"' << writer.getCFICodeAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("PutOrCall": )"; - builder << '"' << writer.putOrCall() << '"'; - - builder << ", "; - builder << R"("MaturityMonthYear": )"; - builder << writer.maturityMonthYear(); - - builder << ", "; - builder << R"("Currency": )"; - builder << '"' << writer.getCurrencyAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("StrikePrice": )"; - builder << writer.strikePrice(); - - builder << ", "; - builder << R"("StrikeCurrency": )"; - builder << '"' << writer.getStrikeCurrencyAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("SettlCurrency": )"; - builder << '"' << writer.getSettlCurrencyAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("MinCabPrice": )"; - builder << writer.minCabPrice(); - - builder << ", "; - builder << R"("MatchAlgorithm": )"; - if (std::isprint(writer.matchAlgorithm())) { - builder << '"' << (char)writer.matchAlgorithm() << '"'; - } else { - builder << (int)writer.matchAlgorithm(); - } - - builder << ", "; - builder << R"("MinTradeVol": )"; - builder << +writer.minTradeVol(); - - builder << ", "; - builder << R"("MaxTradeVol": )"; - builder << +writer.maxTradeVol(); - - builder << ", "; - builder << R"("MinPriceIncrement": )"; - builder << writer.minPriceIncrement(); - - builder << ", "; - builder << R"("MinPriceIncrementAmount": )"; - builder << writer.minPriceIncrementAmount(); - - builder << ", "; - builder << R"("DisplayFactor": )"; - builder << writer.displayFactor(); - - builder << ", "; - builder << R"("TickRule": )"; - builder << +writer.tickRule(); - - builder << ", "; - builder << R"("MainFraction": )"; - builder << +writer.mainFraction(); - - builder << ", "; - builder << R"("SubFraction": )"; - builder << +writer.subFraction(); - - builder << ", "; - builder << R"("PriceDisplayFormat": )"; - builder << +writer.priceDisplayFormat(); - - builder << ", "; - builder << R"("UnitOfMeasure": )"; - builder << '"' << writer.getUnitOfMeasureAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("UnitOfMeasureQty": )"; - builder << writer.unitOfMeasureQty(); - - builder << ", "; - builder << R"("TradingReferencePrice": )"; - builder << writer.tradingReferencePrice(); - - builder << ", "; - builder << R"("SettlPriceType": )"; - builder << writer.settlPriceType(); - - builder << ", "; - builder << R"("ClearedVolume": )"; - builder << +writer.clearedVolume(); - - builder << ", "; - builder << R"("OpenInterestQty": )"; - builder << +writer.openInterestQty(); - - builder << ", "; - builder << R"("LowLimitPrice": )"; - builder << writer.lowLimitPrice(); - - builder << ", "; - builder << R"("HighLimitPrice": )"; - builder << writer.highLimitPrice(); - - builder << ", "; - builder << R"("UserDefinedInstrument": )"; - if (std::isprint(writer.userDefinedInstrument())) { - builder << '"' << (char)writer.userDefinedInstrument() << '"'; - } else { - builder << (int)writer.userDefinedInstrument(); - } - - builder << ", "; - builder << R"("TradingReferenceDate": )"; - builder << +writer.tradingReferenceDate(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoEvents": [)"; - writer.noEvents().forEach([&](NoEvents &noEvents) { - if (atLeastOne) { - builder << ", "; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDInstrumentDefinitionOption41 _writer) +{ + MDInstrumentDefinitionOption41 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDInstrumentDefinitionOption41", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); + + builder << ", "; + builder << R"("TotNumReports": )"; + builder << +writer.totNumReports(); + + builder << ", "; + builder << R"("SecurityUpdateAction": )"; + builder << '"' << writer.securityUpdateAction() << '"'; + + builder << ", "; + builder << R"("LastUpdateTime": )"; + builder << +writer.lastUpdateTime(); + + builder << ", "; + builder << R"("MDSecurityTradingStatus": )"; + builder << '"' << writer.mDSecurityTradingStatus() << '"'; + + builder << ", "; + builder << R"("ApplID": )"; + builder << +writer.applID(); + + builder << ", "; + builder << R"("MarketSegmentID": )"; + builder << +writer.marketSegmentID(); + + builder << ", "; + builder << R"("UnderlyingProduct": )"; + builder << +writer.underlyingProduct(); + + builder << ", "; + builder << R"("SecurityExchange": )"; + builder << '"' << + writer.getSecurityExchangeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityGroup": )"; + builder << '"' << + writer.getSecurityGroupAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("Asset": )"; + builder << '"' << + writer.getAssetAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("Symbol": )"; + builder << '"' << + writer.getSymbolAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("SecurityType": )"; + builder << '"' << + writer.getSecurityTypeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("CFICode": )"; + builder << '"' << + writer.getCFICodeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("PutOrCall": )"; + builder << '"' << writer.putOrCall() << '"'; + + builder << ", "; + builder << R"("MaturityMonthYear": )"; + builder << writer.maturityMonthYear(); + + builder << ", "; + builder << R"("Currency": )"; + builder << '"' << + writer.getCurrencyAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("StrikePrice": )"; + builder << writer.strikePrice(); + + builder << ", "; + builder << R"("StrikeCurrency": )"; + builder << '"' << + writer.getStrikeCurrencyAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SettlCurrency": )"; + builder << '"' << + writer.getSettlCurrencyAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("MinCabPrice": )"; + builder << writer.minCabPrice(); + + builder << ", "; + builder << R"("MatchAlgorithm": )"; + if (std::isprint(writer.matchAlgorithm())) + { + builder << '"' << (char)writer.matchAlgorithm() << '"'; + } + else + { + builder << (int)writer.matchAlgorithm(); + } + + builder << ", "; + builder << R"("MinTradeVol": )"; + builder << +writer.minTradeVol(); + + builder << ", "; + builder << R"("MaxTradeVol": )"; + builder << +writer.maxTradeVol(); + + builder << ", "; + builder << R"("MinPriceIncrement": )"; + builder << writer.minPriceIncrement(); + + builder << ", "; + builder << R"("MinPriceIncrementAmount": )"; + builder << writer.minPriceIncrementAmount(); + + builder << ", "; + builder << R"("DisplayFactor": )"; + builder << writer.displayFactor(); + + builder << ", "; + builder << R"("TickRule": )"; + builder << +writer.tickRule(); + + builder << ", "; + builder << R"("MainFraction": )"; + builder << +writer.mainFraction(); + + builder << ", "; + builder << R"("SubFraction": )"; + builder << +writer.subFraction(); + + builder << ", "; + builder << R"("PriceDisplayFormat": )"; + builder << +writer.priceDisplayFormat(); + + builder << ", "; + builder << R"("UnitOfMeasure": )"; + builder << '"' << + writer.getUnitOfMeasureAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("UnitOfMeasureQty": )"; + builder << writer.unitOfMeasureQty(); + + builder << ", "; + builder << R"("TradingReferencePrice": )"; + builder << writer.tradingReferencePrice(); + + builder << ", "; + builder << R"("SettlPriceType": )"; + builder << writer.settlPriceType(); + + builder << ", "; + builder << R"("ClearedVolume": )"; + builder << +writer.clearedVolume(); + + builder << ", "; + builder << R"("OpenInterestQty": )"; + builder << +writer.openInterestQty(); + + builder << ", "; + builder << R"("LowLimitPrice": )"; + builder << writer.lowLimitPrice(); + + builder << ", "; + builder << R"("HighLimitPrice": )"; + builder << writer.highLimitPrice(); + + builder << ", "; + builder << R"("UserDefinedInstrument": )"; + if (std::isprint(writer.userDefinedInstrument())) + { + builder << '"' << (char)writer.userDefinedInstrument() << '"'; + } + else + { + builder << (int)writer.userDefinedInstrument(); + } + + builder << ", "; + builder << R"("TradingReferenceDate": )"; + builder << +writer.tradingReferenceDate(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoEvents": [)"; + writer.noEvents().forEach([&](NoEvents& noEvents) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noEvents; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDFeedTypes": [)"; - writer.noMDFeedTypes().forEach([&](NoMDFeedTypes &noMDFeedTypes) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDFeedTypes": [)"; + writer.noMDFeedTypes().forEach([&](NoMDFeedTypes& noMDFeedTypes) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDFeedTypes; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoInstAttrib": [)"; - writer.noInstAttrib().forEach([&](NoInstAttrib &noInstAttrib) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoInstAttrib": [)"; + writer.noInstAttrib().forEach([&](NoInstAttrib& noInstAttrib) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noInstAttrib; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoLotTypeRules": [)"; - writer.noLotTypeRules().forEach([&](NoLotTypeRules &noLotTypeRules) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoLotTypeRules": [)"; + writer.noLotTypeRules().forEach([&](NoLotTypeRules& noLotTypeRules) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noLotTypeRules; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoUnderlyings": [)"; - writer.noUnderlyings().forEach([&](NoUnderlyings &noUnderlyings) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoUnderlyings": [)"; + writer.noUnderlyings().forEach([&](NoUnderlyings& noUnderlyings) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noUnderlyings; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoRelatedInstruments": [)"; - writer.noRelatedInstruments().forEach( - [&](NoRelatedInstruments &noRelatedInstruments) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noRelatedInstruments; - }); - builder << ']'; - } + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoRelatedInstruments": [)"; + writer.noRelatedInstruments().forEach([&](NoRelatedInstruments& noRelatedInstruments) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noRelatedInstruments; + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noEvents().forEach([](NoEvents e) + { + e.skip(); + }); + noMDFeedTypes().forEach([](NoMDFeedTypes e) + { + e.skip(); + }); + noInstAttrib().forEach([](NoInstAttrib e) + { + e.skip(); + }); + noLotTypeRules().forEach([](NoLotTypeRules e) + { + e.skip(); + }); + noUnderlyings().forEach([](NoUnderlyings e) + { + e.skip(); + }); + noRelatedInstruments().forEach([](NoRelatedInstruments e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noEventsLength = 0, + std::size_t noMDFeedTypesLength = 0, + std::size_t noInstAttribLength = 0, + std::size_t noLotTypeRulesLength = 0, + std::size_t noUnderlyingsLength = 0, + std::size_t noRelatedInstrumentsLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoEvents::sbeHeaderSize(); + if (noEventsLength > 254LL) + { + throw std::runtime_error("noEventsLength outside of allowed range [E110]"); + } + length += noEventsLength *NoEvents::sbeBlockLength(); + + length += NoMDFeedTypes::sbeHeaderSize(); + if (noMDFeedTypesLength > 254LL) + { + throw std::runtime_error("noMDFeedTypesLength outside of allowed range [E110]"); + } + length += noMDFeedTypesLength *NoMDFeedTypes::sbeBlockLength(); + + length += NoInstAttrib::sbeHeaderSize(); + if (noInstAttribLength > 254LL) + { + throw std::runtime_error("noInstAttribLength outside of allowed range [E110]"); + } + length += noInstAttribLength *NoInstAttrib::sbeBlockLength(); + + length += NoLotTypeRules::sbeHeaderSize(); + if (noLotTypeRulesLength > 254LL) + { + throw std::runtime_error("noLotTypeRulesLength outside of allowed range [E110]"); + } + length += noLotTypeRulesLength *NoLotTypeRules::sbeBlockLength(); + + length += NoUnderlyings::sbeHeaderSize(); + if (noUnderlyingsLength > 254LL) + { + throw std::runtime_error("noUnderlyingsLength outside of allowed range [E110]"); + } + length += noUnderlyingsLength *NoUnderlyings::sbeBlockLength(); + + length += NoRelatedInstruments::sbeHeaderSize(); + if (noRelatedInstrumentsLength > 254LL) + { + throw std::runtime_error("noRelatedInstrumentsLength outside of allowed range [E110]"); + } + length += noRelatedInstrumentsLength *NoRelatedInstruments::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionOption55.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionOption55.h index aaea1c4b0..c2763e12c 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionOption55.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionOption55.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,7085 +86,7693 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDInstrumentDefinitionOption55 { - 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 MDInstrumentDefinitionOption55 +{ +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; } + 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(213); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(55); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDInstrumentDefinitionOption55() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDInstrumentDefinitionOption55( - 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; - MDInstrumentDefinitionOption55( - char *buffer, const std::uint64_t bufferLength) - : MDInstrumentDefinitionOption55( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDInstrumentDefinitionOption55() = default; - MDInstrumentDefinitionOption55( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDInstrumentDefinitionOption55( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDInstrumentDefinitionOption55( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)213; - } + MDInstrumentDefinitionOption55(char *buffer, const std::uint64_t bufferLength) : + MDInstrumentDefinitionOption55(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)55; - } + MDInstrumentDefinitionOption55( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDInstrumentDefinitionOption55(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(213); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "d"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(55); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDInstrumentDefinitionOption55 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDInstrumentDefinitionOption55( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDInstrumentDefinitionOption55 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "d"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDInstrumentDefinitionOption55( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDInstrumentDefinitionOption55 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDInstrumentDefinitionOption55(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDInstrumentDefinitionOption55 &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 = MDInstrumentDefinitionOption55( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDInstrumentDefinitionOption55 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDInstrumentDefinitionOption55( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDInstrumentDefinitionOption55 &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 = MDInstrumentDefinitionOption55(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MDInstrumentDefinitionOption55 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char *MatchEventIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MultipleCharValue"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char * - TotNumReportsMetaAttribute(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 *TotNumReportsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT { - return 911; - } + static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT + { + return 911; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totNumReportsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t totNumReportsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= totNumReportsSinceVersion(); + return m_actingVersion >= totNumReportsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totNumReportsEncodingOffset() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t totNumReportsEncodingOffset() SBE_NOEXCEPT + { + return 1; + } - static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t totNumReports() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t totNumReports() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionOption55 & - totNumReports(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint32_t)); - return *this; - } + MDInstrumentDefinitionOption55 &totNumReports(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char *SecurityUpdateActionMetaAttribute( - 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 *SecurityUpdateActionMetaAttribute(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 securityUpdateActionId() SBE_NOEXCEPT { - return 980; - } + static SBE_CONSTEXPR std::uint16_t securityUpdateActionId() SBE_NOEXCEPT + { + return 980; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityUpdateActionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityUpdateActionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityUpdateActionSinceVersion(); + return m_actingVersion >= securityUpdateActionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SecurityUpdateAction::Value - securityUpdateAction() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 5, sizeof(char)); - return SecurityUpdateAction::get((val)); - } + SBE_NODISCARD SecurityUpdateAction::Value securityUpdateAction() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 5, sizeof(char)); + return SecurityUpdateAction::get((val)); + } - MDInstrumentDefinitionOption55 & - securityUpdateAction(const SecurityUpdateAction::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 5, &val, sizeof(char)); - return *this; - } + MDInstrumentDefinitionOption55 &securityUpdateAction(const SecurityUpdateAction::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 5, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char * - LastUpdateTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LastUpdateTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t lastUpdateTimeId() SBE_NOEXCEPT { - return 779; - } + static SBE_CONSTEXPR std::uint16_t lastUpdateTimeId() SBE_NOEXCEPT + { + return 779; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastUpdateTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastUpdateTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lastUpdateTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lastUpdateTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastUpdateTimeSinceVersion(); + return m_actingVersion >= lastUpdateTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastUpdateTimeEncodingOffset() SBE_NOEXCEPT { - return 6; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastUpdateTimeEncodingOffset() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - lastUpdateTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t lastUpdateTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t lastUpdateTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 6, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t lastUpdateTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 6, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MDInstrumentDefinitionOption55 & - lastUpdateTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 6, &val, sizeof(std::uint64_t)); - return *this; - } + MDInstrumentDefinitionOption55 &lastUpdateTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 6, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *MDSecurityTradingStatusMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MDSecurityTradingStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mDSecurityTradingStatusId() SBE_NOEXCEPT { - return 1682; - } + static SBE_CONSTEXPR std::uint16_t mDSecurityTradingStatusId() SBE_NOEXCEPT + { + return 1682; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDSecurityTradingStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDSecurityTradingStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mDSecurityTradingStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mDSecurityTradingStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDSecurityTradingStatusSinceVersion(); + return m_actingVersion >= mDSecurityTradingStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDSecurityTradingStatusEncodingOffset() SBE_NOEXCEPT { - return 14; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDSecurityTradingStatusEncodingOffset() SBE_NOEXCEPT + { + return 14; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDSecurityTradingStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDSecurityTradingStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SecurityTradingStatus::Value - mDSecurityTradingStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); - return SecurityTradingStatus::get((val)); - } + SBE_NODISCARD SecurityTradingStatus::Value mDSecurityTradingStatus() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); + return SecurityTradingStatus::get((val)); + } - MDInstrumentDefinitionOption55 &mDSecurityTradingStatus( - const SecurityTradingStatus::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionOption55 &mDSecurityTradingStatus(const SecurityTradingStatus::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - ApplIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ApplIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t applIDId() SBE_NOEXCEPT { return 1180; } + static SBE_CONSTEXPR std::uint16_t applIDId() SBE_NOEXCEPT + { + return 1180; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - applIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t applIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool applIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool applIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= applIDSinceVersion(); + return m_actingVersion >= applIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - applIDEncodingOffset() SBE_NOEXCEPT { - return 15; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t applIDEncodingOffset() SBE_NOEXCEPT + { + return 15; + } - static SBE_CONSTEXPR std::int16_t applIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT16; - } + static SBE_CONSTEXPR std::int16_t applIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT16; + } - static SBE_CONSTEXPR std::int16_t applIDMinValue() SBE_NOEXCEPT { - return (std::int16_t)-32767; - } + static SBE_CONSTEXPR std::int16_t applIDMinValue() SBE_NOEXCEPT + { + return static_cast(-32767); + } - static SBE_CONSTEXPR std::int16_t applIDMaxValue() SBE_NOEXCEPT { - return (std::int16_t)32767; - } + static SBE_CONSTEXPR std::int16_t applIDMaxValue() SBE_NOEXCEPT + { + return static_cast(32767); + } - static SBE_CONSTEXPR std::size_t applIDEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t applIDEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::int16_t applID() const SBE_NOEXCEPT { - std::int16_t val; - std::memcpy(&val, m_buffer + m_offset + 15, sizeof(std::int16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::int16_t applID() const SBE_NOEXCEPT + { + std::int16_t val; + std::memcpy(&val, m_buffer + m_offset + 15, sizeof(std::int16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - MDInstrumentDefinitionOption55 & - applID(const std::int16_t value) SBE_NOEXCEPT { - std::int16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 15, &val, sizeof(std::int16_t)); - return *this; - } + MDInstrumentDefinitionOption55 &applID(const std::int16_t value) SBE_NOEXCEPT + { + std::int16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 15, &val, sizeof(std::int16_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 "required"; - 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 "required"; + 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 17; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t marketSegmentIDEncodingOffset() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } - 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 + 17, 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 + 17, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionOption55 & - marketSegmentID(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionOption55 &marketSegmentID(const std::uint8_t 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 *UnderlyingProductMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UnderlyingProductMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t underlyingProductId() SBE_NOEXCEPT { - return 462; - } + static SBE_CONSTEXPR std::uint16_t underlyingProductId() SBE_NOEXCEPT + { + return 462; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - underlyingProductSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t underlyingProductSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool underlyingProductInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool underlyingProductInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= underlyingProductSinceVersion(); + return m_actingVersion >= underlyingProductSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - underlyingProductEncodingOffset() SBE_NOEXCEPT { - return 18; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t underlyingProductEncodingOffset() SBE_NOEXCEPT + { + return 18; + } - static SBE_CONSTEXPR std::uint8_t underlyingProductNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR std::uint8_t underlyingProductNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } - static SBE_CONSTEXPR std::uint8_t underlyingProductMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t underlyingProductMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t underlyingProductMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t underlyingProductMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - underlyingProductEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t underlyingProductEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t underlyingProduct() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t underlyingProduct() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionOption55 & - underlyingProduct(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; - } + MDInstrumentDefinitionOption55 &underlyingProduct(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 static const char *SecurityExchangeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Exchange"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityExchangeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Exchange"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityExchangeId() SBE_NOEXCEPT { - return 207; - } + static SBE_CONSTEXPR std::uint16_t securityExchangeId() SBE_NOEXCEPT + { + return 207; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityExchangeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityExchangeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityExchangeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityExchangeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityExchangeSinceVersion(); + return m_actingVersion >= securityExchangeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityExchangeEncodingOffset() SBE_NOEXCEPT { - return 19; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityExchangeEncodingOffset() SBE_NOEXCEPT + { + return 19; + } - static SBE_CONSTEXPR char securityExchangeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityExchangeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityExchangeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityExchangeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityExchangeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char securityExchangeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - securityExchangeEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityExchangeEncodingLength() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t securityExchangeLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::uint64_t securityExchangeLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD const char *securityExchange() const SBE_NOEXCEPT { - return m_buffer + m_offset + 19; - } + SBE_NODISCARD const char *securityExchange() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 19; + } - SBE_NODISCARD char *securityExchange() SBE_NOEXCEPT { - return m_buffer + m_offset + 19; - } + SBE_NODISCARD char *securityExchange() SBE_NOEXCEPT + { + return m_buffer + m_offset + 19; + } - SBE_NODISCARD char securityExchange(const std::uint64_t index) const { - if (index >= 4) { - throw std::runtime_error( - "index out of range for securityExchange [E104]"); - } + SBE_NODISCARD char securityExchange(const std::uint64_t index) const + { + if (index >= 4) + { + throw std::runtime_error("index out of range for securityExchange [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 19 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 19 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption55 & - securityExchange(const std::uint64_t index, const char value) { - if (index >= 4) { - throw std::runtime_error( - "index out of range for securityExchange [E105]"); - } + MDInstrumentDefinitionOption55 &securityExchange(const std::uint64_t index, const char value) + { + if (index >= 4) + { + throw std::runtime_error("index out of range for securityExchange [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 19 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 19 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSecurityExchange(char *const dst, const std::uint64_t length) const { - if (length > 4) { - throw std::runtime_error( - "length too large for getSecurityExchange [E106]"); - } + std::uint64_t getSecurityExchange(char *const dst, const std::uint64_t length) const + { + if (length > 4) + { + throw std::runtime_error("length too large for getSecurityExchange [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 19, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 19, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionOption55 & - putSecurityExchange(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 19, src, sizeof(char) * 4); - return *this; - } + MDInstrumentDefinitionOption55 &putSecurityExchange(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 19, src, sizeof(char) * 4); + return *this; + } - MDInstrumentDefinitionOption55 &putSecurityExchange( - const char value0, - const char value1, - const char value2, - const char value3) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 19, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 20, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 21, &val2, sizeof(char)); - char val3 = (value3); - std::memcpy(m_buffer + m_offset + 22, &val3, sizeof(char)); + MDInstrumentDefinitionOption55 &putSecurityExchange( + const char value0, + const char value1, + const char value2, + const char value3) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 19, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 20, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 21, &val2, sizeof(char)); + char val3 = (value3); + std::memcpy(m_buffer + m_offset + 22, &val3, sizeof(char)); - return *this; - } + return *this; + } - std::string getSecurityExchangeAsString() const { - const char *buffer = m_buffer + m_offset + 19; - size_t length = 0; + SBE_NODISCARD std::string getSecurityExchangeAsString() const + { + const char *buffer = m_buffer + m_offset + 19; + size_t length = 0; - for (; length < 4 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 4 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSecurityExchangeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityExchangeAsString(); + std::string getSecurityExchangeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityExchangeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityExchangeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 19; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityExchangeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 19; + size_t length = 0; - for (; length < 4 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 4 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - MDInstrumentDefinitionOption55 & - putSecurityExchange(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 4) { - throw std::runtime_error( - "string too large for putSecurityExchange [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionOption55 &putSecurityExchange(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 4) + { + throw std::runtime_error("string too large for putSecurityExchange [E106]"); + } - std::memcpy(m_buffer + m_offset + 19, str.data(), srcLength); - for (size_t start = srcLength; start < 4; ++start) { - m_buffer[m_offset + 19 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 19, str.data(), srcLength); + for (size_t start = srcLength; start < 4; ++start) + { + m_buffer[m_offset + 19 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption55 &putSecurityExchange(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 4) { - throw std::runtime_error( - "string too large for putSecurityExchange [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionOption55 &putSecurityExchange(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 4) + { + throw std::runtime_error("string too large for putSecurityExchange [E106]"); + } - std::memcpy(m_buffer + m_offset + 19, str.c_str(), srcLength); - for (size_t start = srcLength; start < 4; ++start) { - m_buffer[m_offset + 19 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 19, str.c_str(), srcLength); + for (size_t start = srcLength; start < 4; ++start) + { + m_buffer[m_offset + 19 + start] = 0; + } - return *this; - } -#endif + return *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 "required"; - 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 "required"; + 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 23; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityGroupEncodingOffset() SBE_NOEXCEPT + { + return 23; + } - 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 + 23; - } + SBE_NODISCARD const char *securityGroup() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 23; + } - SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT { - return m_buffer + m_offset + 23; - } + SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT + { + return m_buffer + m_offset + 23; + } - 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 + 23 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 23 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption55 & - securityGroup(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E105]"); - } + MDInstrumentDefinitionOption55 &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 + 23 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 23 + (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 + 23, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 23, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionOption55 & - putSecurityGroup(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 23, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionOption55 &putSecurityGroup(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 23, src, sizeof(char) * 6); + return *this; + } - std::string getSecurityGroupAsString() const { - const char *buffer = m_buffer + m_offset + 23; - size_t length = 0; + SBE_NODISCARD std::string getSecurityGroupAsString() const + { + const char *buffer = m_buffer + m_offset + 23; + 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 (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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityGroupAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 23; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 23; + 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 - MDInstrumentDefinitionOption55 & - 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 + MDInstrumentDefinitionOption55 &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 + 23, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 23 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 23, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 23 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption55 &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 + MDInstrumentDefinitionOption55 &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 + 23, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 23 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 23, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 23 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - AssetMetaAttribute(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 *AssetMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t assetId() SBE_NOEXCEPT { return 6937; } + static SBE_CONSTEXPR std::uint16_t assetId() SBE_NOEXCEPT + { + return 6937; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - assetSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t assetSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool assetInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool assetInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= assetSinceVersion(); + return m_actingVersion >= assetSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - assetEncodingOffset() SBE_NOEXCEPT { - return 29; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t assetEncodingOffset() SBE_NOEXCEPT + { + return 29; + } - static SBE_CONSTEXPR char assetNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char assetNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char assetMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char assetMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char assetMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char assetMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t assetEncodingLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::size_t assetEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t assetLength() SBE_NOEXCEPT { return 6; } + static SBE_CONSTEXPR std::uint64_t assetLength() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD const char *asset() const SBE_NOEXCEPT { - return m_buffer + m_offset + 29; - } + SBE_NODISCARD const char *asset() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 29; + } - SBE_NODISCARD char *asset() SBE_NOEXCEPT { return m_buffer + m_offset + 29; } + SBE_NODISCARD char *asset() SBE_NOEXCEPT + { + return m_buffer + m_offset + 29; + } - SBE_NODISCARD char asset(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for asset [E104]"); - } + SBE_NODISCARD char asset(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for asset [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 29 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 29 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption55 & - asset(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for asset [E105]"); - } + MDInstrumentDefinitionOption55 &asset(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for asset [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 29 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 29 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getAsset(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error("length too large for getAsset [E106]"); - } + std::uint64_t getAsset(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getAsset [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 29, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 29, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionOption55 & - putAsset(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 29, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionOption55 &putAsset(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 29, src, sizeof(char) * 6); + return *this; + } - std::string getAssetAsString() const { - const char *buffer = m_buffer + m_offset + 29; - size_t length = 0; + SBE_NODISCARD std::string getAssetAsString() const + { + const char *buffer = m_buffer + m_offset + 29; + 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 getAssetAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getAssetAsString(); + std::string getAssetAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getAssetAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getAssetAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 29; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getAssetAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 29; + 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 - MDInstrumentDefinitionOption55 &putAsset(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putAsset [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionOption55 &putAsset(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putAsset [E106]"); + } - std::memcpy(m_buffer + m_offset + 29, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 29 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 29, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 29 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption55 &putAsset(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putAsset [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionOption55 &putAsset(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putAsset [E106]"); + } - std::memcpy(m_buffer + m_offset + 29, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 29 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 29, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 29 + start] = 0; + } - return *this; - } -#endif + 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 "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SymbolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t symbolId() SBE_NOEXCEPT { return 55; } + 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 static SBE_CONSTEXPR std::uint64_t symbolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool symbolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool symbolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= symbolSinceVersion(); + return m_actingVersion >= symbolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - symbolEncodingOffset() SBE_NOEXCEPT { - return 35; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t symbolEncodingOffset() SBE_NOEXCEPT + { + return 35; + } - static SBE_CONSTEXPR char symbolNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char symbolNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char symbolMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char symbolMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char symbolMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char symbolMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t symbolEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t symbolEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t symbolLength() 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 + 35; - } + SBE_NODISCARD const char *symbol() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 35; + } - SBE_NODISCARD char *symbol() SBE_NOEXCEPT { - return m_buffer + m_offset + 35; - } + SBE_NODISCARD char *symbol() SBE_NOEXCEPT + { + return m_buffer + m_offset + 35; + } - SBE_NODISCARD char symbol(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for symbol [E104]"); - } + 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 + 35 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 35 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption55 & - symbol(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for symbol [E105]"); - } + MDInstrumentDefinitionOption55 &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 + 35 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 35 + (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::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 + 35, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 35, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionOption55 & - putSymbol(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 35, src, sizeof(char) * 20); - return *this; - } + MDInstrumentDefinitionOption55 &putSymbol(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 35, src, sizeof(char) * 20); + return *this; + } - std::string getSymbolAsString() const { - const char *buffer = m_buffer + m_offset + 35; - size_t length = 0; + SBE_NODISCARD std::string getSymbolAsString() const + { + const char *buffer = m_buffer + m_offset + 35; + 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 getSymbolAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSymbolAsString(); + std::string getSymbolAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSymbolAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSymbolAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 35; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSymbolAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 35; + 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 - MDInstrumentDefinitionOption55 &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]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionOption55 &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 + 35, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 35 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 35, str.data(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 35 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption55 &putSymbol(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSymbol [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionOption55 &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 + 35, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 35 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 35, str.c_str(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 35 + 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 55; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 55; + } - 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 + 55, 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 + 55, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionOption55 & - securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 55, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionOption55 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 55, &val, sizeof(std::int32_t)); + return *this; + } - 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 ""; - } - } + 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; - } + 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 static SBE_CONSTEXPR std::uint64_t securityIDSourceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDSourceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDSourceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSourceSinceVersion(); + return m_actingVersion >= securityIDSourceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDSourceEncodingOffset() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDSourceEncodingOffset() SBE_NOEXCEPT + { + return 59; + } - static SBE_CONSTEXPR char securityIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityIDSourceNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityIDSourceMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityIDSourceMaxValue() SBE_NOEXCEPT { - return (char)126; - } + 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::size_t securityIDSourceEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t securityIDSourceLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t securityIDSourceLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *securityIDSource() const { - static const std::uint8_t securityIDSourceValues[] = {56}; + SBE_NODISCARD const char *securityIDSource() const + { + static const std::uint8_t securityIDSourceValues[] = { 56 }; - return (const char *)securityIDSourceValues; - } + return (const char *)securityIDSourceValues; + } - SBE_NODISCARD char securityIDSource(const std::uint64_t index) const { - static const std::uint8_t securityIDSourceValues[] = {56}; + SBE_NODISCARD char securityIDSource(const std::uint64_t index) const + { + static const std::uint8_t securityIDSourceValues[] = { 56 }; - return (char)securityIDSourceValues[index]; - } + 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::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::memcpy(dst, securityIDSourceValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getSecurityIDSourceAsString() const { - static const std::uint8_t SecurityIDSourceValues[] = {56}; + std::string getSecurityIDSourceAsString() const + { + static const std::uint8_t SecurityIDSourceValues[] = { 56 }; - return std::string((const char *)SecurityIDSourceValues, 1); - } + return std::string((const char *)SecurityIDSourceValues, 1); + } - std::string getSecurityIDSourceAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityIDSourceAsString(); + std::string getSecurityIDSourceAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityIDSourceAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 * - SecurityTypeMetaAttribute(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 *SecurityTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityTypeId() SBE_NOEXCEPT { - return 167; - } + 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 static SBE_CONSTEXPR std::uint64_t securityTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityTypeSinceVersion(); + return m_actingVersion >= securityTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityTypeEncodingOffset() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityTypeEncodingOffset() SBE_NOEXCEPT + { + return 59; + } - static SBE_CONSTEXPR char securityTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + 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::size_t securityTypeEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t securityTypeLength() 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 + 59; - } + SBE_NODISCARD const char *securityType() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 59; + } - SBE_NODISCARD char *securityType() SBE_NOEXCEPT { - return m_buffer + m_offset + 59; - } + SBE_NODISCARD char *securityType() SBE_NOEXCEPT + { + return m_buffer + m_offset + 59; + } - SBE_NODISCARD char securityType(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for securityType [E104]"); - } + 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 + 59 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 59 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption55 & - securityType(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for securityType [E105]"); - } + MDInstrumentDefinitionOption55 &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 + 59 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 59 + (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::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 + 59, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 59, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionOption55 & - putSecurityType(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 59, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionOption55 &putSecurityType(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 59, src, sizeof(char) * 6); + return *this; + } - std::string getSecurityTypeAsString() const { - const char *buffer = m_buffer + m_offset + 59; - size_t length = 0; + SBE_NODISCARD std::string getSecurityTypeAsString() const + { + const char *buffer = m_buffer + m_offset + 59; + 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 getSecurityTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityTypeAsString(); + std::string getSecurityTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityTypeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityTypeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 59; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityTypeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 59; + 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 - MDInstrumentDefinitionOption55 &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]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionOption55 &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 + 59, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 59 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 59, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 59 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption55 &putSecurityType(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityType [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionOption55 &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 + 59, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 59 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 59, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 59 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - CFICodeMetaAttribute(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 *CFICodeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t cFICodeId() SBE_NOEXCEPT { return 461; } + static SBE_CONSTEXPR std::uint16_t cFICodeId() SBE_NOEXCEPT + { + return 461; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cFICodeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cFICodeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool cFICodeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool cFICodeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= cFICodeSinceVersion(); + return m_actingVersion >= cFICodeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cFICodeEncodingOffset() SBE_NOEXCEPT { - return 65; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cFICodeEncodingOffset() SBE_NOEXCEPT + { + return 65; + } - static SBE_CONSTEXPR char cFICodeNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char cFICodeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char cFICodeMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char cFICodeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char cFICodeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char cFICodeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t cFICodeEncodingLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::size_t cFICodeEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t cFICodeLength() SBE_NOEXCEPT { return 6; } + static SBE_CONSTEXPR std::uint64_t cFICodeLength() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD const char *cFICode() const SBE_NOEXCEPT { - return m_buffer + m_offset + 65; - } + SBE_NODISCARD const char *cFICode() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 65; + } - SBE_NODISCARD char *cFICode() SBE_NOEXCEPT { - return m_buffer + m_offset + 65; - } + SBE_NODISCARD char *cFICode() SBE_NOEXCEPT + { + return m_buffer + m_offset + 65; + } - SBE_NODISCARD char cFICode(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for cFICode [E104]"); - } + SBE_NODISCARD char cFICode(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for cFICode [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); + } - MDInstrumentDefinitionOption55 & - cFICode(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for cFICode [E105]"); - } + MDInstrumentDefinitionOption55 &cFICode(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for cFICode [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 getCFICode(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error("length too large for getCFICode [E106]"); - } + std::uint64_t getCFICode(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getCFICode [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; + } - MDInstrumentDefinitionOption55 & - putCFICode(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 65, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionOption55 &putCFICode(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 65, src, sizeof(char) * 6); + return *this; + } - std::string getCFICodeAsString() const { - const char *buffer = m_buffer + m_offset + 65; - size_t length = 0; + SBE_NODISCARD std::string getCFICodeAsString() const + { + const char *buffer = m_buffer + m_offset + 65; + 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 getCFICodeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCFICodeAsString(); + std::string getCFICodeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCFICodeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getCFICodeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 65; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCFICodeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 65; + 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 - MDInstrumentDefinitionOption55 &putCFICode(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putCFICode [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionOption55 &putCFICode(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putCFICode [E106]"); + } - std::memcpy(m_buffer + m_offset + 65, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 65 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 65, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 65 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption55 &putCFICode(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putCFICode [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionOption55 &putCFICode(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putCFICode [E106]"); + } - std::memcpy(m_buffer + m_offset + 65, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 65 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 65, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 65 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - PutOrCallMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *PutOrCallMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t putOrCallId() SBE_NOEXCEPT { return 201; } + static SBE_CONSTEXPR std::uint16_t putOrCallId() SBE_NOEXCEPT + { + return 201; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - putOrCallSinceVersion() SBE_NOEXCEPT { - return 3; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t putOrCallSinceVersion() SBE_NOEXCEPT + { + return 3; + } - SBE_NODISCARD bool putOrCallInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool putOrCallInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= putOrCallSinceVersion(); + return m_actingVersion >= putOrCallSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - putOrCallEncodingOffset() SBE_NOEXCEPT { - return 71; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t putOrCallEncodingOffset() SBE_NOEXCEPT + { + return 71; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - putOrCallEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t putOrCallEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD PutOrCall::Value putOrCall() const SBE_NOEXCEPT { - if (m_actingVersion < 3) { - return PutOrCall::NULL_VALUE; - } + SBE_NODISCARD PutOrCall::Value putOrCall() const + { + if (m_actingVersion < 3) + { + return PutOrCall::NULL_VALUE; + } - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 71, sizeof(std::uint8_t)); - return PutOrCall::get((val)); - } + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 71, sizeof(std::uint8_t)); + return PutOrCall::get((val)); + } - MDInstrumentDefinitionOption55 & - putOrCall(const PutOrCall::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 71, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionOption55 &putOrCall(const PutOrCall::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 static const char *MaturityMonthYearMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MonthYear"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + 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; - } + 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 static SBE_CONSTEXPR std::uint64_t maturityMonthYearSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool maturityMonthYearInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool maturityMonthYearInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= maturityMonthYearSinceVersion(); + return m_actingVersion >= maturityMonthYearSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maturityMonthYearEncodingOffset() SBE_NOEXCEPT { - return 72; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maturityMonthYearEncodingOffset() SBE_NOEXCEPT + { + return 72; + } - private: - MaturityMonthYear m_maturityMonthYear; +private: + MaturityMonthYear m_maturityMonthYear; - public: - SBE_NODISCARD MaturityMonthYear &maturityMonthYear() { - m_maturityMonthYear.wrap( - m_buffer, m_offset + 72, m_actingVersion, m_bufferLength); - return m_maturityMonthYear; - } +public: + SBE_NODISCARD MaturityMonthYear &maturityMonthYear() + { + m_maturityMonthYear.wrap(m_buffer, m_offset + 72, m_actingVersion, m_bufferLength); + return m_maturityMonthYear; + } - SBE_NODISCARD static const char * - CurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Currency"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Currency"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t currencyId() SBE_NOEXCEPT { return 15; } + 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 static SBE_CONSTEXPR std::uint64_t currencySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool currencyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool currencyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= currencySinceVersion(); + return m_actingVersion >= currencySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - currencyEncodingOffset() SBE_NOEXCEPT { - return 77; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t currencyEncodingOffset() SBE_NOEXCEPT + { + return 77; + } - static SBE_CONSTEXPR char currencyNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char currencyNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char currencyMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char currencyMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char currencyMaxValue() SBE_NOEXCEPT { - return (char)126; - } + 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::size_t currencyEncodingLength() SBE_NOEXCEPT + { + return 3; + } - static SBE_CONSTEXPR std::uint64_t currencyLength() 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 + 77; - } + SBE_NODISCARD const char *currency() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 77; + } - SBE_NODISCARD char *currency() SBE_NOEXCEPT { - return m_buffer + m_offset + 77; - } + SBE_NODISCARD char *currency() SBE_NOEXCEPT + { + return m_buffer + m_offset + 77; + } - SBE_NODISCARD char currency(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error("index out of range for currency [E104]"); - } + 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 + 77 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 77 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption55 & - currency(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error("index out of range for currency [E105]"); - } + MDInstrumentDefinitionOption55 ¤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 + 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 - getCurrency(char *const dst, const std::uint64_t length) const { - if (length > 3) { - throw std::runtime_error("length too large for getCurrency [E106]"); - } + 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 + 77, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 77, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionOption55 & - putCurrency(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 77, src, sizeof(char) * 3); - return *this; - } + MDInstrumentDefinitionOption55 &putCurrency(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 77, src, sizeof(char) * 3); + return *this; + } - MDInstrumentDefinitionOption55 &putCurrency( - const char value0, const char value1, const char value2) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 77, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 78, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 79, &val2, sizeof(char)); + MDInstrumentDefinitionOption55 &putCurrency( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 77, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 78, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 79, &val2, sizeof(char)); - return *this; - } + return *this; + } - std::string getCurrencyAsString() const { - const char *buffer = m_buffer + m_offset + 77; - size_t length = 0; + SBE_NODISCARD std::string getCurrencyAsString() const + { + const char *buffer = m_buffer + m_offset + 77; + 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 getCurrencyAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCurrencyAsString(); + std::string getCurrencyAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCurrencyAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getCurrencyAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 77; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCurrencyAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 77; + 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 - MDInstrumentDefinitionOption55 &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]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionOption55 &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 + 77, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 77 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 77, str.data(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 77 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption55 &putCurrency(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error("string too large for putCurrency [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionOption55 &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 + 77, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 77 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 77, str.c_str(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 77 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - StrikePriceMetaAttribute(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 *StrikePriceMetaAttribute(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 strikePriceId() SBE_NOEXCEPT { - return 202; - } + static SBE_CONSTEXPR std::uint16_t strikePriceId() SBE_NOEXCEPT + { + return 202; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - strikePriceSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t strikePriceSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool strikePriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool strikePriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= strikePriceSinceVersion(); + return m_actingVersion >= strikePriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - strikePriceEncodingOffset() SBE_NOEXCEPT { - return 80; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t strikePriceEncodingOffset() SBE_NOEXCEPT + { + return 80; + } - private: - PRICENULL9 m_strikePrice; +private: + PRICENULL9 m_strikePrice; - public: - SBE_NODISCARD PRICENULL9 &strikePrice() { - m_strikePrice.wrap( - m_buffer, m_offset + 80, m_actingVersion, m_bufferLength); - return m_strikePrice; - } +public: + SBE_NODISCARD PRICENULL9 &strikePrice() + { + m_strikePrice.wrap(m_buffer, m_offset + 80, m_actingVersion, m_bufferLength); + return m_strikePrice; + } - SBE_NODISCARD static const char * - StrikeCurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Currency"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *StrikeCurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Currency"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t strikeCurrencyId() SBE_NOEXCEPT { - return 947; - } + static SBE_CONSTEXPR std::uint16_t strikeCurrencyId() SBE_NOEXCEPT + { + return 947; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - strikeCurrencySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t strikeCurrencySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool strikeCurrencyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool strikeCurrencyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= strikeCurrencySinceVersion(); + return m_actingVersion >= strikeCurrencySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - strikeCurrencyEncodingOffset() SBE_NOEXCEPT { - return 88; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t strikeCurrencyEncodingOffset() SBE_NOEXCEPT + { + return 88; + } - static SBE_CONSTEXPR char strikeCurrencyNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char strikeCurrencyNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char strikeCurrencyMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char strikeCurrencyMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char strikeCurrencyMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char strikeCurrencyMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - strikeCurrencyEncodingLength() SBE_NOEXCEPT { - return 3; - } + static SBE_CONSTEXPR std::size_t strikeCurrencyEncodingLength() SBE_NOEXCEPT + { + return 3; + } - static SBE_CONSTEXPR std::uint64_t strikeCurrencyLength() SBE_NOEXCEPT { - return 3; - } + static SBE_CONSTEXPR std::uint64_t strikeCurrencyLength() SBE_NOEXCEPT + { + return 3; + } - SBE_NODISCARD const char *strikeCurrency() const SBE_NOEXCEPT { - return m_buffer + m_offset + 88; - } + SBE_NODISCARD const char *strikeCurrency() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 88; + } - SBE_NODISCARD char *strikeCurrency() SBE_NOEXCEPT { - return m_buffer + m_offset + 88; - } + SBE_NODISCARD char *strikeCurrency() SBE_NOEXCEPT + { + return m_buffer + m_offset + 88; + } - SBE_NODISCARD char strikeCurrency(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error( - "index out of range for strikeCurrency [E104]"); - } + SBE_NODISCARD char strikeCurrency(const std::uint64_t index) const + { + if (index >= 3) + { + throw std::runtime_error("index out of range for strikeCurrency [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 88 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 88 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption55 & - strikeCurrency(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error( - "index out of range for strikeCurrency [E105]"); - } + MDInstrumentDefinitionOption55 &strikeCurrency(const std::uint64_t index, const char value) + { + if (index >= 3) + { + throw std::runtime_error("index out of range for strikeCurrency [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 88 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 88 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getStrikeCurrency(char *const dst, const std::uint64_t length) const { - if (length > 3) { - throw std::runtime_error( - "length too large for getStrikeCurrency [E106]"); - } + std::uint64_t getStrikeCurrency(char *const dst, const std::uint64_t length) const + { + if (length > 3) + { + throw std::runtime_error("length too large for getStrikeCurrency [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 88, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 88, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionOption55 & - putStrikeCurrency(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 88, src, sizeof(char) * 3); - return *this; - } + MDInstrumentDefinitionOption55 &putStrikeCurrency(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 88, src, sizeof(char) * 3); + return *this; + } - MDInstrumentDefinitionOption55 &putStrikeCurrency( - const char value0, const char value1, const char value2) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 88, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 89, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 90, &val2, sizeof(char)); + MDInstrumentDefinitionOption55 &putStrikeCurrency( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 88, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 89, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 90, &val2, sizeof(char)); - return *this; - } + return *this; + } - std::string getStrikeCurrencyAsString() const { - const char *buffer = m_buffer + m_offset + 88; - size_t length = 0; + SBE_NODISCARD std::string getStrikeCurrencyAsString() const + { + const char *buffer = m_buffer + m_offset + 88; + 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 getStrikeCurrencyAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getStrikeCurrencyAsString(); + std::string getStrikeCurrencyAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getStrikeCurrencyAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getStrikeCurrencyAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 88; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getStrikeCurrencyAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 88; + 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 - MDInstrumentDefinitionOption55 & - putStrikeCurrency(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putStrikeCurrency [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionOption55 &putStrikeCurrency(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putStrikeCurrency [E106]"); + } - std::memcpy(m_buffer + m_offset + 88, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 88 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 88, str.data(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 88 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption55 &putStrikeCurrency(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putStrikeCurrency [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionOption55 &putStrikeCurrency(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putStrikeCurrency [E106]"); + } - std::memcpy(m_buffer + m_offset + 88, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 88 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 88, str.c_str(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 88 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - SettlCurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Currency"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SettlCurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Currency"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t settlCurrencyId() SBE_NOEXCEPT { - return 120; - } + static SBE_CONSTEXPR std::uint16_t settlCurrencyId() SBE_NOEXCEPT + { + return 120; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - settlCurrencySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t settlCurrencySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool settlCurrencyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool settlCurrencyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= settlCurrencySinceVersion(); + return m_actingVersion >= settlCurrencySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - settlCurrencyEncodingOffset() SBE_NOEXCEPT { - return 91; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t settlCurrencyEncodingOffset() SBE_NOEXCEPT + { + return 91; + } - static SBE_CONSTEXPR char settlCurrencyNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char settlCurrencyNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char settlCurrencyMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char settlCurrencyMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char settlCurrencyMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char settlCurrencyMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t settlCurrencyEncodingLength() SBE_NOEXCEPT { - return 3; - } + static SBE_CONSTEXPR std::size_t settlCurrencyEncodingLength() SBE_NOEXCEPT + { + return 3; + } - static SBE_CONSTEXPR std::uint64_t settlCurrencyLength() SBE_NOEXCEPT { - return 3; - } + static SBE_CONSTEXPR std::uint64_t settlCurrencyLength() SBE_NOEXCEPT + { + return 3; + } - SBE_NODISCARD const char *settlCurrency() const SBE_NOEXCEPT { - return m_buffer + m_offset + 91; - } + SBE_NODISCARD const char *settlCurrency() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 91; + } - SBE_NODISCARD char *settlCurrency() SBE_NOEXCEPT { - return m_buffer + m_offset + 91; - } + SBE_NODISCARD char *settlCurrency() SBE_NOEXCEPT + { + return m_buffer + m_offset + 91; + } - SBE_NODISCARD char settlCurrency(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error( - "index out of range for settlCurrency [E104]"); - } + SBE_NODISCARD char settlCurrency(const std::uint64_t index) const + { + if (index >= 3) + { + throw std::runtime_error("index out of range for settlCurrency [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 91 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 91 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption55 & - settlCurrency(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error( - "index out of range for settlCurrency [E105]"); - } + MDInstrumentDefinitionOption55 &settlCurrency(const std::uint64_t index, const char value) + { + if (index >= 3) + { + throw std::runtime_error("index out of range for settlCurrency [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 91 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 91 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSettlCurrency(char *const dst, const std::uint64_t length) const { - if (length > 3) { - throw std::runtime_error( - "length too large for getSettlCurrency [E106]"); - } + std::uint64_t getSettlCurrency(char *const dst, const std::uint64_t length) const + { + if (length > 3) + { + throw std::runtime_error("length too large for getSettlCurrency [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 91, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 91, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionOption55 & - putSettlCurrency(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 91, src, sizeof(char) * 3); - return *this; - } + MDInstrumentDefinitionOption55 &putSettlCurrency(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 91, src, sizeof(char) * 3); + return *this; + } - MDInstrumentDefinitionOption55 &putSettlCurrency( - const char value0, const char value1, const char value2) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 91, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 92, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 93, &val2, sizeof(char)); + MDInstrumentDefinitionOption55 &putSettlCurrency( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 91, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 92, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 93, &val2, sizeof(char)); - return *this; - } + return *this; + } - std::string getSettlCurrencyAsString() const { - const char *buffer = m_buffer + m_offset + 91; - size_t length = 0; + SBE_NODISCARD std::string getSettlCurrencyAsString() const + { + const char *buffer = m_buffer + m_offset + 91; + 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 getSettlCurrencyAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSettlCurrencyAsString(); + std::string getSettlCurrencyAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSettlCurrencyAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSettlCurrencyAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 91; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSettlCurrencyAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 91; + 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 - MDInstrumentDefinitionOption55 & - putSettlCurrency(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putSettlCurrency [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionOption55 &putSettlCurrency(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putSettlCurrency [E106]"); + } - std::memcpy(m_buffer + m_offset + 91, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 91 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 91, str.data(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 91 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption55 &putSettlCurrency(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putSettlCurrency [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionOption55 &putSettlCurrency(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putSettlCurrency [E106]"); + } - std::memcpy(m_buffer + m_offset + 91, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 91 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 91, str.c_str(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 91 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - MinCabPriceMetaAttribute(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 *MinCabPriceMetaAttribute(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 minCabPriceId() SBE_NOEXCEPT { - return 9850; - } + static SBE_CONSTEXPR std::uint16_t minCabPriceId() SBE_NOEXCEPT + { + return 9850; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minCabPriceSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minCabPriceSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool minCabPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minCabPriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minCabPriceSinceVersion(); + return m_actingVersion >= minCabPriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minCabPriceEncodingOffset() SBE_NOEXCEPT { - return 94; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minCabPriceEncodingOffset() SBE_NOEXCEPT + { + return 94; + } - private: - PRICENULL9 m_minCabPrice; +private: + PRICENULL9 m_minCabPrice; - public: - SBE_NODISCARD PRICENULL9 &minCabPrice() { - m_minCabPrice.wrap( - m_buffer, m_offset + 94, m_actingVersion, m_bufferLength); - return m_minCabPrice; - } +public: + SBE_NODISCARD PRICENULL9 &minCabPrice() + { + m_minCabPrice.wrap(m_buffer, m_offset + 94, m_actingVersion, m_bufferLength); + return m_minCabPrice; + } - SBE_NODISCARD static const char * - MatchAlgorithmMetaAttribute(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 *MatchAlgorithmMetaAttribute(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 matchAlgorithmId() SBE_NOEXCEPT { - return 1142; - } + static SBE_CONSTEXPR std::uint16_t matchAlgorithmId() SBE_NOEXCEPT + { + return 1142; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchAlgorithmSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchAlgorithmSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchAlgorithmInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchAlgorithmInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchAlgorithmSinceVersion(); + return m_actingVersion >= matchAlgorithmSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchAlgorithmEncodingOffset() SBE_NOEXCEPT { - return 102; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchAlgorithmEncodingOffset() SBE_NOEXCEPT + { + return 102; + } - static SBE_CONSTEXPR char matchAlgorithmNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char matchAlgorithmNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char matchAlgorithmMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char matchAlgorithmMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char matchAlgorithmMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char matchAlgorithmMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - matchAlgorithmEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchAlgorithmEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD char matchAlgorithm() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 102, sizeof(char)); - return (val); - } + SBE_NODISCARD char matchAlgorithm() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 102, sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption55 & - matchAlgorithm(const char value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 102, &val, sizeof(char)); - return *this; - } + MDInstrumentDefinitionOption55 &matchAlgorithm(const char value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 102, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char * - MinTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MinTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t minTradeVolId() SBE_NOEXCEPT { - return 562; - } + static SBE_CONSTEXPR std::uint16_t minTradeVolId() SBE_NOEXCEPT + { + return 562; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minTradeVolSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minTradeVolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minTradeVolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minTradeVolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minTradeVolSinceVersion(); + return m_actingVersion >= minTradeVolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minTradeVolEncodingOffset() SBE_NOEXCEPT { - return 103; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minTradeVolEncodingOffset() SBE_NOEXCEPT + { + return 103; + } - static SBE_CONSTEXPR std::uint32_t minTradeVolNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t minTradeVolNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t minTradeVolMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t minTradeVolMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t minTradeVolMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t minTradeVolMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t minTradeVolEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t minTradeVolEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t minTradeVol() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 103, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t minTradeVol() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 103, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionOption55 & - minTradeVol(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 103, &val, sizeof(std::uint32_t)); - return *this; - } + MDInstrumentDefinitionOption55 &minTradeVol(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 103, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - MaxTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MaxTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t maxTradeVolId() SBE_NOEXCEPT { - return 1140; - } + static SBE_CONSTEXPR std::uint16_t maxTradeVolId() SBE_NOEXCEPT + { + return 1140; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - maxTradeVolSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maxTradeVolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool maxTradeVolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool maxTradeVolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= maxTradeVolSinceVersion(); + return m_actingVersion >= maxTradeVolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maxTradeVolEncodingOffset() SBE_NOEXCEPT { - return 107; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maxTradeVolEncodingOffset() SBE_NOEXCEPT + { + return 107; + } - static SBE_CONSTEXPR std::uint32_t maxTradeVolNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t maxTradeVolNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t maxTradeVolMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t maxTradeVolMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t maxTradeVolMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t maxTradeVolMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t maxTradeVolEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t maxTradeVolEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t maxTradeVol() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 107, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t maxTradeVol() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 107, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionOption55 & - maxTradeVol(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 107, &val, sizeof(std::uint32_t)); - return *this; - } + MDInstrumentDefinitionOption55 &maxTradeVol(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 107, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char *MinPriceIncrementMetaAttribute( - 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 *MinPriceIncrementMetaAttribute(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 minPriceIncrementId() SBE_NOEXCEPT { - return 969; - } + static SBE_CONSTEXPR std::uint16_t minPriceIncrementId() SBE_NOEXCEPT + { + return 969; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minPriceIncrementSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minPriceIncrementSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool minPriceIncrementInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minPriceIncrementInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minPriceIncrementSinceVersion(); + return m_actingVersion >= minPriceIncrementSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minPriceIncrementEncodingOffset() SBE_NOEXCEPT { - return 111; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minPriceIncrementEncodingOffset() SBE_NOEXCEPT + { + return 111; + } - private: - PRICENULL9 m_minPriceIncrement; +private: + PRICENULL9 m_minPriceIncrement; - public: - SBE_NODISCARD PRICENULL9 &minPriceIncrement() { - m_minPriceIncrement.wrap( - m_buffer, m_offset + 111, m_actingVersion, m_bufferLength); - return m_minPriceIncrement; - } +public: + SBE_NODISCARD PRICENULL9 &minPriceIncrement() + { + m_minPriceIncrement.wrap(m_buffer, m_offset + 111, m_actingVersion, m_bufferLength); + return m_minPriceIncrement; + } - SBE_NODISCARD static const char *MinPriceIncrementAmountMetaAttribute( - 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 *MinPriceIncrementAmountMetaAttribute(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 minPriceIncrementAmountId() SBE_NOEXCEPT { - return 1146; - } + static SBE_CONSTEXPR std::uint16_t minPriceIncrementAmountId() SBE_NOEXCEPT + { + return 1146; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minPriceIncrementAmountSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minPriceIncrementAmountSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool minPriceIncrementAmountInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minPriceIncrementAmountInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minPriceIncrementAmountSinceVersion(); + return m_actingVersion >= minPriceIncrementAmountSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minPriceIncrementAmountEncodingOffset() SBE_NOEXCEPT { - return 119; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minPriceIncrementAmountEncodingOffset() SBE_NOEXCEPT + { + return 119; + } - private: - PRICENULL9 m_minPriceIncrementAmount; +private: + PRICENULL9 m_minPriceIncrementAmount; - public: - SBE_NODISCARD PRICENULL9 &minPriceIncrementAmount() { - m_minPriceIncrementAmount.wrap( - m_buffer, m_offset + 119, m_actingVersion, m_bufferLength); - return m_minPriceIncrementAmount; - } +public: + SBE_NODISCARD PRICENULL9 &minPriceIncrementAmount() + { + m_minPriceIncrementAmount.wrap(m_buffer, m_offset + 119, m_actingVersion, m_bufferLength); + return m_minPriceIncrementAmount; + } - SBE_NODISCARD static const char * - DisplayFactorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "float"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DisplayFactorMetaAttribute(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 displayFactorId() SBE_NOEXCEPT { - return 9787; - } + static SBE_CONSTEXPR std::uint16_t displayFactorId() SBE_NOEXCEPT + { + return 9787; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - displayFactorSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t displayFactorSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool displayFactorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool displayFactorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= displayFactorSinceVersion(); + return m_actingVersion >= displayFactorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - displayFactorEncodingOffset() SBE_NOEXCEPT { - return 127; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t displayFactorEncodingOffset() SBE_NOEXCEPT + { + return 127; + } - private: - Decimal9 m_displayFactor; +private: + Decimal9 m_displayFactor; - public: - SBE_NODISCARD Decimal9 &displayFactor() { - m_displayFactor.wrap( - m_buffer, m_offset + 127, m_actingVersion, m_bufferLength); - return m_displayFactor; - } +public: + SBE_NODISCARD Decimal9 &displayFactor() + { + m_displayFactor.wrap(m_buffer, m_offset + 127, m_actingVersion, m_bufferLength); + return m_displayFactor; + } - SBE_NODISCARD static const char * - TickRuleMetaAttribute(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 *TickRuleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t tickRuleId() SBE_NOEXCEPT { return 6350; } + static SBE_CONSTEXPR std::uint16_t tickRuleId() SBE_NOEXCEPT + { + return 6350; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tickRuleSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tickRuleSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool tickRuleInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tickRuleInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tickRuleSinceVersion(); + return m_actingVersion >= tickRuleSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tickRuleEncodingOffset() SBE_NOEXCEPT { - return 135; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tickRuleEncodingOffset() SBE_NOEXCEPT + { + return 135; + } - static SBE_CONSTEXPR std::int8_t tickRuleNullValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t tickRuleNullValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::int8_t tickRuleMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } + static SBE_CONSTEXPR std::int8_t tickRuleMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } - static SBE_CONSTEXPR std::int8_t tickRuleMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t tickRuleMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::size_t tickRuleEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t tickRuleEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::int8_t tickRule() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 135, sizeof(std::int8_t)); - return (val); - } + SBE_NODISCARD std::int8_t tickRule() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 135, sizeof(std::int8_t)); + return (val); + } - MDInstrumentDefinitionOption55 & - tickRule(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 135, &val, sizeof(std::int8_t)); - return *this; - } + MDInstrumentDefinitionOption55 &tickRule(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 135, &val, sizeof(std::int8_t)); + return *this; + } - SBE_NODISCARD static const char * - MainFractionMetaAttribute(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 *MainFractionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mainFractionId() SBE_NOEXCEPT { - return 37702; - } + static SBE_CONSTEXPR std::uint16_t mainFractionId() SBE_NOEXCEPT + { + return 37702; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mainFractionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mainFractionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mainFractionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mainFractionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mainFractionSinceVersion(); + return m_actingVersion >= mainFractionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mainFractionEncodingOffset() SBE_NOEXCEPT { - return 136; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mainFractionEncodingOffset() SBE_NOEXCEPT + { + return 136; + } - static SBE_CONSTEXPR std::uint8_t mainFractionNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t mainFractionNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t mainFractionMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t mainFractionMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t mainFractionMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t mainFractionMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t mainFractionEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t mainFractionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t mainFraction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 136, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t mainFraction() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 136, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionOption55 & - mainFraction(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 136, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionOption55 &mainFraction(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 136, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - SubFractionMetaAttribute(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 *SubFractionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t subFractionId() SBE_NOEXCEPT { - return 37703; - } + static SBE_CONSTEXPR std::uint16_t subFractionId() SBE_NOEXCEPT + { + return 37703; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - subFractionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t subFractionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool subFractionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool subFractionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= subFractionSinceVersion(); + return m_actingVersion >= subFractionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - subFractionEncodingOffset() SBE_NOEXCEPT { - return 137; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t subFractionEncodingOffset() SBE_NOEXCEPT + { + return 137; + } - static SBE_CONSTEXPR std::uint8_t subFractionNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t subFractionNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t subFractionMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t subFractionMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t subFractionMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t subFractionMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t subFractionEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t subFractionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t subFraction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 137, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t subFraction() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 137, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionOption55 & - subFraction(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 137, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionOption55 &subFraction(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 137, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char *PriceDisplayFormatMetaAttribute( - 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 *PriceDisplayFormatMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t priceDisplayFormatId() SBE_NOEXCEPT { - return 9800; - } + static SBE_CONSTEXPR std::uint16_t priceDisplayFormatId() SBE_NOEXCEPT + { + return 9800; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceDisplayFormatSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceDisplayFormatSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool priceDisplayFormatInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool priceDisplayFormatInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= priceDisplayFormatSinceVersion(); + return m_actingVersion >= priceDisplayFormatSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceDisplayFormatEncodingOffset() SBE_NOEXCEPT { - return 138; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceDisplayFormatEncodingOffset() SBE_NOEXCEPT + { + return 138; + } - static SBE_CONSTEXPR std::uint8_t - priceDisplayFormatNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t priceDisplayFormatNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - priceDisplayFormatEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t priceDisplayFormatEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t priceDisplayFormat() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 138, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t priceDisplayFormat() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 138, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionOption55 & - priceDisplayFormat(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 138, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionOption55 &priceDisplayFormat(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 138, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - UnitOfMeasureMetaAttribute(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 *UnitOfMeasureMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t unitOfMeasureId() SBE_NOEXCEPT { - return 996; - } + static SBE_CONSTEXPR std::uint16_t unitOfMeasureId() SBE_NOEXCEPT + { + return 996; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - unitOfMeasureSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t unitOfMeasureSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool unitOfMeasureInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool unitOfMeasureInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= unitOfMeasureSinceVersion(); + return m_actingVersion >= unitOfMeasureSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - unitOfMeasureEncodingOffset() SBE_NOEXCEPT { - return 139; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t unitOfMeasureEncodingOffset() SBE_NOEXCEPT + { + return 139; + } - static SBE_CONSTEXPR char unitOfMeasureNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char unitOfMeasureNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char unitOfMeasureMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char unitOfMeasureMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char unitOfMeasureMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char unitOfMeasureMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t unitOfMeasureEncodingLength() SBE_NOEXCEPT { - return 30; - } + static SBE_CONSTEXPR std::size_t unitOfMeasureEncodingLength() SBE_NOEXCEPT + { + return 30; + } - static SBE_CONSTEXPR std::uint64_t unitOfMeasureLength() SBE_NOEXCEPT { - return 30; - } + static SBE_CONSTEXPR std::uint64_t unitOfMeasureLength() SBE_NOEXCEPT + { + return 30; + } - SBE_NODISCARD const char *unitOfMeasure() const SBE_NOEXCEPT { - return m_buffer + m_offset + 139; - } + SBE_NODISCARD const char *unitOfMeasure() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 139; + } - SBE_NODISCARD char *unitOfMeasure() SBE_NOEXCEPT { - return m_buffer + m_offset + 139; - } + SBE_NODISCARD char *unitOfMeasure() SBE_NOEXCEPT + { + return m_buffer + m_offset + 139; + } - SBE_NODISCARD char unitOfMeasure(const std::uint64_t index) const { - if (index >= 30) { - throw std::runtime_error( - "index out of range for unitOfMeasure [E104]"); - } + SBE_NODISCARD char unitOfMeasure(const std::uint64_t index) const + { + if (index >= 30) + { + throw std::runtime_error("index out of range for unitOfMeasure [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 139 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 139 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption55 & - unitOfMeasure(const std::uint64_t index, const char value) { - if (index >= 30) { - throw std::runtime_error( - "index out of range for unitOfMeasure [E105]"); - } + MDInstrumentDefinitionOption55 &unitOfMeasure(const std::uint64_t index, const char value) + { + if (index >= 30) + { + throw std::runtime_error("index out of range for unitOfMeasure [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 139 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 139 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getUnitOfMeasure(char *const dst, const std::uint64_t length) const { - if (length > 30) { - throw std::runtime_error( - "length too large for getUnitOfMeasure [E106]"); - } + std::uint64_t getUnitOfMeasure(char *const dst, const std::uint64_t length) const + { + if (length > 30) + { + throw std::runtime_error("length too large for getUnitOfMeasure [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 139, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 139, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionOption55 & - putUnitOfMeasure(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 139, src, sizeof(char) * 30); - return *this; - } + MDInstrumentDefinitionOption55 &putUnitOfMeasure(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 139, src, sizeof(char) * 30); + return *this; + } - std::string getUnitOfMeasureAsString() const { - const char *buffer = m_buffer + m_offset + 139; - size_t length = 0; + SBE_NODISCARD std::string getUnitOfMeasureAsString() const + { + const char *buffer = m_buffer + m_offset + 139; + 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 getUnitOfMeasureAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getUnitOfMeasureAsString(); + std::string getUnitOfMeasureAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getUnitOfMeasureAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getUnitOfMeasureAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 139; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getUnitOfMeasureAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 139; + 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 - MDInstrumentDefinitionOption55 & - putUnitOfMeasure(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 30) { - throw std::runtime_error( - "string too large for putUnitOfMeasure [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionOption55 &putUnitOfMeasure(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 30) + { + throw std::runtime_error("string too large for putUnitOfMeasure [E106]"); + } - std::memcpy(m_buffer + m_offset + 139, str.data(), srcLength); - for (size_t start = srcLength; start < 30; ++start) { - m_buffer[m_offset + 139 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 139, str.data(), srcLength); + for (size_t start = srcLength; start < 30; ++start) + { + m_buffer[m_offset + 139 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionOption55 &putUnitOfMeasure(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 30) { - throw std::runtime_error( - "string too large for putUnitOfMeasure [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionOption55 &putUnitOfMeasure(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 30) + { + throw std::runtime_error("string too large for putUnitOfMeasure [E106]"); + } - std::memcpy(m_buffer + m_offset + 139, str.c_str(), srcLength); - for (size_t start = srcLength; start < 30; ++start) { - m_buffer[m_offset + 139 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 139, str.c_str(), srcLength); + for (size_t start = srcLength; start < 30; ++start) + { + m_buffer[m_offset + 139 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *UnitOfMeasureQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *UnitOfMeasureQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t unitOfMeasureQtyId() SBE_NOEXCEPT { - return 1147; - } + static SBE_CONSTEXPR std::uint16_t unitOfMeasureQtyId() SBE_NOEXCEPT + { + return 1147; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - unitOfMeasureQtySinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t unitOfMeasureQtySinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool unitOfMeasureQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool unitOfMeasureQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= unitOfMeasureQtySinceVersion(); + return m_actingVersion >= unitOfMeasureQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - unitOfMeasureQtyEncodingOffset() SBE_NOEXCEPT { - return 169; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t unitOfMeasureQtyEncodingOffset() SBE_NOEXCEPT + { + return 169; + } - private: - Decimal9NULL m_unitOfMeasureQty; +private: + Decimal9NULL m_unitOfMeasureQty; - public: - SBE_NODISCARD Decimal9NULL &unitOfMeasureQty() { - m_unitOfMeasureQty.wrap( - m_buffer, m_offset + 169, m_actingVersion, m_bufferLength); - return m_unitOfMeasureQty; - } +public: + SBE_NODISCARD Decimal9NULL &unitOfMeasureQty() + { + m_unitOfMeasureQty.wrap(m_buffer, m_offset + 169, m_actingVersion, m_bufferLength); + return m_unitOfMeasureQty; + } - SBE_NODISCARD static const char *TradingReferencePriceMetaAttribute( - 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 *TradingReferencePriceMetaAttribute(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 tradingReferencePriceId() SBE_NOEXCEPT { - return 1150; - } + static SBE_CONSTEXPR std::uint16_t tradingReferencePriceId() SBE_NOEXCEPT + { + return 1150; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingReferencePriceSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingReferencePriceSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool tradingReferencePriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tradingReferencePriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tradingReferencePriceSinceVersion(); + return m_actingVersion >= tradingReferencePriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingReferencePriceEncodingOffset() SBE_NOEXCEPT { - return 177; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingReferencePriceEncodingOffset() SBE_NOEXCEPT + { + return 177; + } - private: - PRICENULL9 m_tradingReferencePrice; +private: + PRICENULL9 m_tradingReferencePrice; - public: - SBE_NODISCARD PRICENULL9 &tradingReferencePrice() { - m_tradingReferencePrice.wrap( - m_buffer, m_offset + 177, m_actingVersion, m_bufferLength); - return m_tradingReferencePrice; - } +public: + SBE_NODISCARD PRICENULL9 &tradingReferencePrice() + { + m_tradingReferencePrice.wrap(m_buffer, m_offset + 177, m_actingVersion, m_bufferLength); + return m_tradingReferencePrice; + } - SBE_NODISCARD static const char * - SettlPriceTypeMetaAttribute(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 *SettlPriceTypeMetaAttribute(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 settlPriceTypeId() SBE_NOEXCEPT { - return 731; - } + static SBE_CONSTEXPR std::uint16_t settlPriceTypeId() SBE_NOEXCEPT + { + return 731; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - settlPriceTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t settlPriceTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= settlPriceTypeSinceVersion(); + return m_actingVersion >= settlPriceTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingOffset() SBE_NOEXCEPT { - return 185; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingOffset() SBE_NOEXCEPT + { + return 185; + } - private: - SettlPriceType m_settlPriceType; +private: + SettlPriceType m_settlPriceType; - public: - SBE_NODISCARD SettlPriceType &settlPriceType() { - m_settlPriceType.wrap( - m_buffer, m_offset + 185, m_actingVersion, m_bufferLength); - return m_settlPriceType; - } +public: + SBE_NODISCARD SettlPriceType &settlPriceType() + { + m_settlPriceType.wrap(m_buffer, m_offset + 185, m_actingVersion, m_bufferLength); + return m_settlPriceType; + } - static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char * - ClearedVolumeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ClearedVolumeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t clearedVolumeId() SBE_NOEXCEPT { - return 5791; - } + static SBE_CONSTEXPR std::uint16_t clearedVolumeId() SBE_NOEXCEPT + { + return 5791; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clearedVolumeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clearedVolumeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool clearedVolumeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool clearedVolumeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clearedVolumeSinceVersion(); + return m_actingVersion >= clearedVolumeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clearedVolumeEncodingOffset() SBE_NOEXCEPT { - return 186; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clearedVolumeEncodingOffset() SBE_NOEXCEPT + { + return 186; + } - static SBE_CONSTEXPR std::int32_t clearedVolumeNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t clearedVolumeNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t clearedVolumeMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t clearedVolumeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t clearedVolumeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t clearedVolumeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t clearedVolumeEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t clearedVolumeEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t clearedVolume() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 186, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t clearedVolume() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 186, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionOption55 & - clearedVolume(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 186, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionOption55 &clearedVolume(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 186, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char *OpenInterestQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OpenInterestQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t openInterestQtyId() SBE_NOEXCEPT { - return 5792; - } + static SBE_CONSTEXPR std::uint16_t openInterestQtyId() SBE_NOEXCEPT + { + return 5792; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - openInterestQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t openInterestQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool openInterestQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool openInterestQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= openInterestQtySinceVersion(); + return m_actingVersion >= openInterestQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - openInterestQtyEncodingOffset() SBE_NOEXCEPT { - return 190; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t openInterestQtyEncodingOffset() SBE_NOEXCEPT + { + return 190; + } - static SBE_CONSTEXPR std::int32_t openInterestQtyNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t openInterestQtyNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t openInterestQtyMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t openInterestQtyMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t openInterestQtyMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t openInterestQtyMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t - openInterestQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t openInterestQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t openInterestQty() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 190, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t openInterestQty() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 190, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionOption55 & - openInterestQty(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 190, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionOption55 &openInterestQty(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 190, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - LowLimitPriceMetaAttribute(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 *LowLimitPriceMetaAttribute(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 lowLimitPriceId() SBE_NOEXCEPT { - return 1148; - } + static SBE_CONSTEXPR std::uint16_t lowLimitPriceId() SBE_NOEXCEPT + { + return 1148; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lowLimitPriceSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lowLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lowLimitPriceSinceVersion(); + return m_actingVersion >= lowLimitPriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lowLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 194; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lowLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 194; + } - private: - PRICENULL9 m_lowLimitPrice; +private: + PRICENULL9 m_lowLimitPrice; - public: - SBE_NODISCARD PRICENULL9 &lowLimitPrice() { - m_lowLimitPrice.wrap( - m_buffer, m_offset + 194, m_actingVersion, m_bufferLength); - return m_lowLimitPrice; - } +public: + SBE_NODISCARD PRICENULL9 &lowLimitPrice() + { + m_lowLimitPrice.wrap(m_buffer, m_offset + 194, m_actingVersion, m_bufferLength); + return m_lowLimitPrice; + } - SBE_NODISCARD static const char * - HighLimitPriceMetaAttribute(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 *HighLimitPriceMetaAttribute(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 highLimitPriceId() SBE_NOEXCEPT { - return 1149; - } + static SBE_CONSTEXPR std::uint16_t highLimitPriceId() SBE_NOEXCEPT + { + return 1149; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - highLimitPriceSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t highLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= highLimitPriceSinceVersion(); + return m_actingVersion >= highLimitPriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - highLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 202; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t highLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 202; + } - private: - PRICENULL9 m_highLimitPrice; +private: + PRICENULL9 m_highLimitPrice; - public: - SBE_NODISCARD PRICENULL9 &highLimitPrice() { - m_highLimitPrice.wrap( - m_buffer, m_offset + 202, m_actingVersion, m_bufferLength); - return m_highLimitPrice; - } +public: + SBE_NODISCARD PRICENULL9 &highLimitPrice() + { + m_highLimitPrice.wrap(m_buffer, m_offset + 202, m_actingVersion, m_bufferLength); + return m_highLimitPrice; + } - SBE_NODISCARD static const char *UserDefinedInstrumentMetaAttribute( - 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 *UserDefinedInstrumentMetaAttribute(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 userDefinedInstrumentId() SBE_NOEXCEPT { - return 9779; - } + 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 static SBE_CONSTEXPR std::uint64_t userDefinedInstrumentSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool userDefinedInstrumentInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool userDefinedInstrumentInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= userDefinedInstrumentSinceVersion(); + return m_actingVersion >= userDefinedInstrumentSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - userDefinedInstrumentEncodingOffset() SBE_NOEXCEPT { - return 210; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t userDefinedInstrumentEncodingOffset() SBE_NOEXCEPT + { + return 210; + } - static SBE_CONSTEXPR char userDefinedInstrumentNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char userDefinedInstrumentNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char userDefinedInstrumentMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char userDefinedInstrumentMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char userDefinedInstrumentMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char userDefinedInstrumentMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - userDefinedInstrumentEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t userDefinedInstrumentEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD char userDefinedInstrument() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 210, sizeof(char)); - return (val); - } + SBE_NODISCARD char userDefinedInstrument() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 210, sizeof(char)); + return (val); + } - MDInstrumentDefinitionOption55 & - userDefinedInstrument(const char value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 210, &val, sizeof(char)); - return *this; - } + MDInstrumentDefinitionOption55 &userDefinedInstrument(const char value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 210, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char *TradingReferenceDateMetaAttribute( - 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 *TradingReferenceDateMetaAttribute(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 tradingReferenceDateId() SBE_NOEXCEPT { - return 5796; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateId() SBE_NOEXCEPT + { + return 5796; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingReferenceDateSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingReferenceDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tradingReferenceDateSinceVersion(); + return m_actingVersion >= tradingReferenceDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingOffset() SBE_NOEXCEPT { - return 211; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingOffset() SBE_NOEXCEPT + { + return 211; + } - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t tradingReferenceDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 211, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t tradingReferenceDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 211, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - MDInstrumentDefinitionOption55 & - tradingReferenceDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 211, &val, sizeof(std::uint16_t)); - return *this; - } + MDInstrumentDefinitionOption55 &tradingReferenceDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 211, &val, sizeof(std::uint16_t)); + return *this; + } - class NoEvents { + class NoEvents + { 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 NoEvents &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(static_cast(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 *EventTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t eventTypeId() SBE_NOEXCEPT + { + return 865; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t eventTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool eventTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= eventTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t eventTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t eventTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD EventType::Value eventType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint8_t)); + return EventType::get((val)); + } + + NoEvents &eventType(const EventType::Value 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 *EventTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t eventTimeId() SBE_NOEXCEPT + { + return 1145; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t eventTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool eventTimeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= eventTimeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t eventTimeEncodingOffset() SBE_NOEXCEPT + { + return 1; + } + + static SBE_CONSTEXPR std::uint64_t eventTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t eventTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t eventTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t eventTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t eventTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoEvents &eventTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint64_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoEvents writer) + { + builder << '{'; + builder << R"("EventType": )"; + builder << '"' << writer.eventType() << '"'; + + builder << ", "; + builder << R"("EventTime": )"; + builder << +writer.eventTime(); + + 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: + NoEvents m_noEvents; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 9; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoEventsId() SBE_NOEXCEPT + { + return 864; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoEvents &noEvents() + { + m_noEvents.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noEvents; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoEvents &noEventsCount(const std::uint8_t count) + { + m_noEvents.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noEvents; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noEventsSinceVersion() 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 NoEvents &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 * - EventTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t eventTypeId() SBE_NOEXCEPT { - return 865; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - eventTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool eventTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noEventsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= eventTypeSinceVersion(); + return m_actingVersion >= noEventsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - eventTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - eventTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD EventType::Value eventType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint8_t)); - return EventType::get((val)); - } - - NoEvents &eventType(const EventType::Value 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 * - EventTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t eventTimeId() SBE_NOEXCEPT { - return 1145; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - eventTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool eventTimeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= eventTimeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - eventTimeEncodingOffset() SBE_NOEXCEPT { - return 1; - } - - static SBE_CONSTEXPR std::uint64_t eventTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t eventTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t eventTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t eventTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t eventTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoEvents &eventTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint64_t)); - return *this; - } - - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoEvents writer) { - builder << '{'; - builder << R"("EventType": )"; - builder << '"' << writer.eventType() << '"'; - - builder << ", "; - builder << R"("EventTime": )"; - builder << +writer.eventTime(); - - builder << '}'; - - return builder; - } - }; - - private: - NoEvents m_noEvents; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoEventsId() SBE_NOEXCEPT { - return 864; - } - - SBE_NODISCARD inline NoEvents &noEvents() { - m_noEvents.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noEvents; - } - - NoEvents &noEventsCount(const std::uint8_t count) { - m_noEvents.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noEvents; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noEventsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noEventsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noEventsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoMDFeedTypes { + class NoMDFeedTypes + { 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(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; + } + + 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 NoMDFeedTypes &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(static_cast(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 *MDFeedTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDFeedTypeId() SBE_NOEXCEPT + { + return 1022; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDFeedTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDFeedTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDFeedTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDFeedTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR char mDFeedTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char mDFeedTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char mDFeedTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t mDFeedTypeEncodingLength() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t mDFeedTypeLength() SBE_NOEXCEPT + { + return 3; + } + + SBE_NODISCARD const char *mDFeedType() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } + + SBE_NODISCARD char *mDFeedType() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } + + SBE_NODISCARD char mDFeedType(const std::uint64_t index) const + { + if (index >= 3) + { + throw std::runtime_error("index out of range for mDFeedType [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } + + NoMDFeedTypes &mDFeedType(const std::uint64_t index, const char value) + { + if (index >= 3) + { + throw std::runtime_error("index out of range for mDFeedType [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getMDFeedType(char *const dst, const std::uint64_t length) const + { + if (length > 3) + { + throw std::runtime_error("length too large for getMDFeedType [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } + + NoMDFeedTypes &putMDFeedType(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 3); + return *this; + } + + NoMDFeedTypes &putMDFeedType( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 0, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 1, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 2, &val2, sizeof(char)); + + return *this; + } + + SBE_NODISCARD std::string getMDFeedTypeAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + size_t length = 0; + + for (; length < 3 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getMDFeedTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getMDFeedTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + 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 getMDFeedTypeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + size_t length = 0; + + for (; length < 3 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoMDFeedTypes &putMDFeedType(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putMDFeedType [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #else + NoMDFeedTypes &putMDFeedType(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putMDFeedType [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *MarketDepthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t marketDepthId() SBE_NOEXCEPT + { + return 264; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t marketDepthSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool marketDepthInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= marketDepthSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t marketDepthEncodingOffset() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::int8_t marketDepthNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t marketDepthMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t marketDepthMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t marketDepthEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::int8_t marketDepth() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 3, sizeof(std::int8_t)); + return (val); + } + + NoMDFeedTypes &marketDepth(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 3, &val, sizeof(std::int8_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDFeedTypes writer) + { + builder << '{'; + builder << R"("MDFeedType": )"; + builder << '"' << + writer.getMDFeedTypeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("MarketDepth": )"; + builder << +writer.marketDepth(); + + 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)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; - } +private: + NoMDFeedTypes m_noMDFeedTypes; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 4; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDFeedTypesId() SBE_NOEXCEPT + { + return 1141; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDFeedTypes &noMDFeedTypes() + { + m_noMDFeedTypes.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDFeedTypes; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDFeedTypes &noMDFeedTypesCount(const std::uint8_t count) + { + m_noMDFeedTypes.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDFeedTypes; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDFeedTypesSinceVersion() 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 NoMDFeedTypes &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 * - MDFeedTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDFeedTypeId() SBE_NOEXCEPT { - return 1022; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDFeedTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDFeedTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noMDFeedTypesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDFeedTypeSinceVersion(); + return m_actingVersion >= noMDFeedTypesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDFeedTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR char mDFeedTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char mDFeedTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char mDFeedTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t mDFeedTypeEncodingLength() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t mDFeedTypeLength() SBE_NOEXCEPT { - return 3; - } - - SBE_NODISCARD const char *mDFeedType() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char *mDFeedType() SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char mDFeedType(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error( - "index out of range for mDFeedType [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } - - NoMDFeedTypes &mDFeedType(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error( - "index out of range for mDFeedType [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getMDFeedType(char *const dst, const std::uint64_t length) const { - if (length > 3) { - throw std::runtime_error( - "length too large for getMDFeedType [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } - - NoMDFeedTypes &putMDFeedType(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 3); - return *this; - } - - NoMDFeedTypes & - putMDFeedType(const char value0, const char value1, const char value2) - SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 0, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 1, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 2, &val2, sizeof(char)); - - return *this; - } - - std::string getMDFeedTypeAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 3 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getMDFeedTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getMDFeedTypeAsString(); - - 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 getMDFeedTypeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 3 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - NoMDFeedTypes &putMDFeedType(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putMDFeedType [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#else - NoMDFeedTypes &putMDFeedType(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putMDFeedType [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - MarketDepthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t marketDepthId() SBE_NOEXCEPT { - return 264; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - marketDepthSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool marketDepthInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= marketDepthSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - marketDepthEncodingOffset() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::int8_t marketDepthNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t marketDepthMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t marketDepthMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t - marketDepthEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::int8_t marketDepth() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 3, sizeof(std::int8_t)); - return (val); - } - - NoMDFeedTypes &marketDepth(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 3, &val, sizeof(std::int8_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDFeedTypes writer) { - builder << '{'; - builder << R"("MDFeedType": )"; - builder << '"' << writer.getMDFeedTypeAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("MarketDepth": )"; - builder << +writer.marketDepth(); - - builder << '}'; - - return builder; - } - }; - - private: - NoMDFeedTypes m_noMDFeedTypes; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDFeedTypesId() SBE_NOEXCEPT { - return 1141; - } - - SBE_NODISCARD inline NoMDFeedTypes &noMDFeedTypes() { - m_noMDFeedTypes.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDFeedTypes; - } - - NoMDFeedTypes &noMDFeedTypesCount(const std::uint8_t count) { - m_noMDFeedTypes.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDFeedTypes; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDFeedTypesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDFeedTypesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDFeedTypesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoInstAttrib { + class NoInstAttrib + { 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(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; + } + + 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 NoInstAttrib &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(static_cast(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 *InstAttribTypeMetaAttribute(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 instAttribTypeId() SBE_NOEXCEPT + { + return 871; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t instAttribTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool instAttribTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= instAttribTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t instAttribTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::int8_t instAttribTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t instAttribTypeMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t instAttribTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t instAttribTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::int8_t instAttribType() SBE_NOEXCEPT + { + return static_cast(24); + } + + SBE_NODISCARD static const char *InstAttribValueMetaAttribute(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 instAttribValueId() SBE_NOEXCEPT + { + return 872; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t instAttribValueSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool instAttribValueInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= instAttribValueSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t instAttribValueEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + private: + InstAttribValue m_instAttribValue; + + public: + SBE_NODISCARD InstAttribValue &instAttribValue() + { + m_instAttribValue.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_instAttribValue; + } + + static SBE_CONSTEXPR std::size_t instAttribValueEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoInstAttrib writer) + { + builder << '{'; + builder << R"("InstAttribValue": )"; + builder << writer.instAttribValue(); + + 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)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; - } +private: + NoInstAttrib m_noInstAttrib; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 4; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoInstAttribId() SBE_NOEXCEPT + { + return 870; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoInstAttrib &noInstAttrib() + { + m_noInstAttrib.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noInstAttrib; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoInstAttrib &noInstAttribCount(const std::uint8_t count) + { + m_noInstAttrib.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noInstAttrib; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noInstAttribSinceVersion() 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 NoInstAttrib &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 *InstAttribTypeMetaAttribute( - 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 instAttribTypeId() SBE_NOEXCEPT { - return 871; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - instAttribTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool instAttribTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noInstAttribInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= instAttribTypeSinceVersion(); + return m_actingVersion >= noInstAttribSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - instAttribTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int8_t instAttribTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t instAttribTypeMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t instAttribTypeMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t - instAttribTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::int8_t - instAttribType() SBE_NOEXCEPT { - return (std::int8_t)24; - } - - SBE_NODISCARD static const char *InstAttribValueMetaAttribute( - 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 instAttribValueId() SBE_NOEXCEPT { - return 872; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - instAttribValueSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool instAttribValueInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= instAttribValueSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - instAttribValueEncodingOffset() SBE_NOEXCEPT { - return 0; - } + } + class NoLotTypeRules + { private: - InstAttribValue m_instAttribValue; + 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 InstAttribValue &instAttribValue() { - m_instAttribValue.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_instAttribValue; - } + 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; + } - static SBE_CONSTEXPR std::size_t - instAttribValueEncodingLength() SBE_NOEXCEPT { - return 4; - } + 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(5)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 5; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoInstAttrib writer) { - builder << '{'; - builder << R"("InstAttribValue": )"; - builder << writer.instAttribValue(); + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } - builder << '}'; + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 5; + } - return builder; - } - }; + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - private: - NoInstAttrib m_noInstAttrib; + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoInstAttribId() SBE_NOEXCEPT { - return 870; - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - SBE_NODISCARD inline NoInstAttrib &noInstAttrib() { - m_noInstAttrib.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noInstAttrib; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - NoInstAttrib &noInstAttribCount(const std::uint8_t count) { - m_noInstAttrib.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noInstAttrib; - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noInstAttribSinceVersion() SBE_NOEXCEPT { - return 0; - } + inline NoLotTypeRules &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 bool noInstAttribInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noInstAttribSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + return *this; + } - class NoLotTypeRules { - 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; + inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT + { + 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 std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + #if __cplusplus < 201103L + template inline void forEach(Func& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - 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; - } + #else + template inline void forEach(Func&& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + #endif + + SBE_NODISCARD static const char *LotTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lotTypeId() SBE_NOEXCEPT + { + return 1093; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lotTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lotTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= lotTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lotTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::int8_t lotTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t lotTypeMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t lotTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t lotTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::int8_t lotType() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int8_t)); + return (val); + } + + NoLotTypeRules &lotType(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int8_t)); + return *this; + } + + SBE_NODISCARD static const char *MinLotSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t minLotSizeId() SBE_NOEXCEPT + { + return 1231; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minLotSizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool minLotSizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= minLotSizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minLotSizeEncodingOffset() SBE_NOEXCEPT + { + return 1; + } + +private: + DecimalQty m_minLotSize; + +public: + SBE_NODISCARD DecimalQty &minLotSize() + { + m_minLotSize.wrap(m_buffer, m_offset + 1, m_actingVersion, m_bufferLength); + return m_minLotSize; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoLotTypeRules writer) + { + builder << '{'; + builder << R"("LotType": )"; + builder << +writer.lotType(); + + builder << ", "; + builder << R"("MinLotSize": )"; + builder << writer.minLotSize(); + + 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)5); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 5; - 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: + NoLotTypeRules m_noLotTypeRules; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 5; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoLotTypeRulesId() SBE_NOEXCEPT + { + return 1234; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoLotTypeRules &noLotTypeRules() + { + m_noLotTypeRules.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLotTypeRules; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoLotTypeRules &noLotTypeRulesCount(const std::uint8_t count) + { + m_noLotTypeRules.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLotTypeRules; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noLotTypeRulesSinceVersion() 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 NoLotTypeRules &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 * - LotTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t lotTypeId() SBE_NOEXCEPT { - return 1093; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lotTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lotTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noLotTypeRulesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lotTypeSinceVersion(); + return m_actingVersion >= noLotTypeRulesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lotTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int8_t lotTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t lotTypeMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t lotTypeMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t lotTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::int8_t lotType() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int8_t)); - return (val); - } - - NoLotTypeRules &lotType(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int8_t)); - return *this; - } - - SBE_NODISCARD static const char * - MinLotSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t minLotSizeId() SBE_NOEXCEPT { - return 1231; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minLotSizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool minLotSizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= minLotSizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minLotSizeEncodingOffset() SBE_NOEXCEPT { - return 1; - } + } + class NoUnderlyings + { private: - DecimalQty m_minLotSize; + 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 DecimalQty &minLotSize() { - m_minLotSize.wrap( - m_buffer, m_offset + 1, m_actingVersion, m_bufferLength); - return m_minLotSize; - } + 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; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoLotTypeRules writer) { - builder << '{'; - builder << R"("LotType": )"; - builder << +writer.lotType(); + 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(24)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 24; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - builder << ", "; - builder << R"("MinLotSize": )"; - builder << writer.minLotSize(); + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } - builder << '}'; + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 24; + } - return builder; - } - }; + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - private: - NoLotTypeRules m_noLotTypeRules; + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoLotTypeRulesId() SBE_NOEXCEPT { - return 1234; - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - SBE_NODISCARD inline NoLotTypeRules &noLotTypeRules() { - m_noLotTypeRules.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLotTypeRules; - } + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - NoLotTypeRules &noLotTypeRulesCount(const std::uint8_t count) { - m_noLotTypeRules.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLotTypeRules; - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noLotTypeRulesSinceVersion() SBE_NOEXCEPT { - return 0; - } + inline NoUnderlyings &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 bool noLotTypeRulesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noLotTypeRulesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } + return *this; + } - class NoUnderlyings { - 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; + inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT + { + 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 std::uint64_t *sbePositionPtr() SBE_NOEXCEPT { - return m_positionPtr; - } + #if __cplusplus < 201103L + template inline void forEach(Func& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - 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; - } + #else + template inline void forEach(Func&& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - inline void wrapForEncode( - char *buffer, - const std::uint8_t count, - std::uint64_t *pos, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { + #endif + + SBE_NODISCARD static const char *UnderlyingSecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + 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 0; + } + + static SBE_CONSTEXPR std::int32_t underlyingSecurityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + 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 + 0, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoUnderlyings &underlyingSecurityID(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 *UnderlyingSecurityIDSourceMetaAttribute(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 underlyingSecurityIDSourceId() SBE_NOEXCEPT + { + return 305; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t underlyingSecurityIDSourceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool underlyingSecurityIDSourceInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= underlyingSecurityIDSourceSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t underlyingSecurityIDSourceEncodingOffset() SBE_NOEXCEPT + { + return 4; + } + + static SBE_CONSTEXPR char underlyingSecurityIDSourceNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char underlyingSecurityIDSourceMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char underlyingSecurityIDSourceMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t underlyingSecurityIDSourceEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t underlyingSecurityIDSourceLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *underlyingSecurityIDSource() const + { + static const std::uint8_t underlyingSecurityIDSourceValues[] = { 56 }; + + return (const char *)underlyingSecurityIDSourceValues; + } + + SBE_NODISCARD char underlyingSecurityIDSource(const std::uint64_t index) const + { + static const std::uint8_t underlyingSecurityIDSourceValues[] = { 56 }; + + return (char)underlyingSecurityIDSourceValues[index]; + } + + std::uint64_t getUnderlyingSecurityIDSource(char *dst, const std::uint64_t length) const + { + static std::uint8_t underlyingSecurityIDSourceValues[] = { 56 }; + std::uint64_t bytesToCopy = length < sizeof(underlyingSecurityIDSourceValues) ? length : sizeof(underlyingSecurityIDSourceValues); + + std::memcpy(dst, underlyingSecurityIDSourceValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getUnderlyingSecurityIDSourceAsString() const + { + static const std::uint8_t UnderlyingSecurityIDSourceValues[] = { 56 }; + + return std::string((const char *)UnderlyingSecurityIDSourceValues, 1); + } + + std::string getUnderlyingSecurityIDSourceAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getUnderlyingSecurityIDSourceAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + 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 *UnderlyingSymbolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t underlyingSymbolId() SBE_NOEXCEPT + { + return 311; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t underlyingSymbolSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool underlyingSymbolInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= underlyingSymbolSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t underlyingSymbolEncodingOffset() SBE_NOEXCEPT + { + return 4; + } + + static SBE_CONSTEXPR char underlyingSymbolNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char underlyingSymbolMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char underlyingSymbolMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t underlyingSymbolEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t underlyingSymbolLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *underlyingSymbol() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 4; + } + + SBE_NODISCARD char *underlyingSymbol() SBE_NOEXCEPT + { + return m_buffer + m_offset + 4; + } + + SBE_NODISCARD char underlyingSymbol(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for underlyingSymbol [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 4 + (index * 1), sizeof(char)); + return (val); + } + + NoUnderlyings &underlyingSymbol(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for underlyingSymbol [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 4 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getUnderlyingSymbol(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getUnderlyingSymbol [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 4, sizeof(char) * static_cast(length)); + return length; + } + + NoUnderlyings &putUnderlyingSymbol(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 4, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getUnderlyingSymbolAsString() const + { + const char *buffer = m_buffer + m_offset + 4; + size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getUnderlyingSymbolAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getUnderlyingSymbolAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + 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 getUnderlyingSymbolAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 4; + size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoUnderlyings &putUnderlyingSymbol(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putUnderlyingSymbol [E106]"); + } + + std::memcpy(m_buffer + m_offset + 4, str.data(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 4 + start] = 0; + } + + return *this; + } + #else + NoUnderlyings &putUnderlyingSymbol(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putUnderlyingSymbol [E106]"); + } + + std::memcpy(m_buffer + m_offset + 4, str.c_str(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 4 + start] = 0; + } + + return *this; + } + #endif + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoUnderlyings writer) + { + builder << '{'; + builder << R"("UnderlyingSecurityID": )"; + builder << +writer.underlyingSecurityID(); + + builder << ", "; + builder << R"("UnderlyingSymbol": )"; + builder << '"' << + writer.getUnderlyingSymbolAsJsonEscapedString().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 - 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)24); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 24; - 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: + NoUnderlyings m_noUnderlyings; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 24; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoUnderlyingsId() SBE_NOEXCEPT + { + return 711; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoUnderlyings &noUnderlyings() + { + m_noUnderlyings.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noUnderlyings; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoUnderlyings &noUnderlyingsCount(const std::uint8_t count) + { + m_noUnderlyings.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noUnderlyings; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noUnderlyingsSinceVersion() 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 NoUnderlyings &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 *UnderlyingSecurityIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - 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 { + SBE_NODISCARD bool noUnderlyingsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= underlyingSecurityIDSinceVersion(); + return m_actingVersion >= noUnderlyingsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - underlyingSecurityIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int32_t - underlyingSecurityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - 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 + 0, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoUnderlyings & - underlyingSecurityID(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 *UnderlyingSecurityIDSourceMetaAttribute( - 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 - underlyingSecurityIDSourceId() SBE_NOEXCEPT { - return 305; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - underlyingSecurityIDSourceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool - underlyingSecurityIDSourceInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= underlyingSecurityIDSourceSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - underlyingSecurityIDSourceEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR char - underlyingSecurityIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char - underlyingSecurityIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char - underlyingSecurityIDSourceMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - underlyingSecurityIDSourceEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t - underlyingSecurityIDSourceLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *underlyingSecurityIDSource() const { - static const std::uint8_t underlyingSecurityIDSourceValues[] = {56}; - - return (const char *)underlyingSecurityIDSourceValues; - } - - SBE_NODISCARD char - underlyingSecurityIDSource(const std::uint64_t index) const { - static const std::uint8_t underlyingSecurityIDSourceValues[] = {56}; - - return (char)underlyingSecurityIDSourceValues[index]; - } - - std::uint64_t getUnderlyingSecurityIDSource( - char *dst, const std::uint64_t length) const { - static std::uint8_t underlyingSecurityIDSourceValues[] = {56}; - std::uint64_t bytesToCopy = - length < sizeof(underlyingSecurityIDSourceValues) - ? length - : sizeof(underlyingSecurityIDSourceValues); - - std::memcpy( - dst, underlyingSecurityIDSourceValues, - static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getUnderlyingSecurityIDSourceAsString() const { - static const std::uint8_t UnderlyingSecurityIDSourceValues[] = {56}; - - return std::string((const char *)UnderlyingSecurityIDSourceValues, 1); - } - - std::string getUnderlyingSecurityIDSourceAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getUnderlyingSecurityIDSourceAsString(); - - 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 *UnderlyingSymbolMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t underlyingSymbolId() SBE_NOEXCEPT { - return 311; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - underlyingSymbolSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool underlyingSymbolInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= underlyingSymbolSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - underlyingSymbolEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR char underlyingSymbolNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char underlyingSymbolMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char underlyingSymbolMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - underlyingSymbolEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t underlyingSymbolLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *underlyingSymbol() const SBE_NOEXCEPT { - return m_buffer + m_offset + 4; - } - - SBE_NODISCARD char *underlyingSymbol() SBE_NOEXCEPT { - return m_buffer + m_offset + 4; - } - - SBE_NODISCARD char underlyingSymbol(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error( - "index out of range for underlyingSymbol [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 4 + (index * 1), sizeof(char)); - return (val); - } - - NoUnderlyings & - underlyingSymbol(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error( - "index out of range for underlyingSymbol [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 4 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getUnderlyingSymbol(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error( - "length too large for getUnderlyingSymbol [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 4, - sizeof(char) * static_cast(length)); - return length; - } - - NoUnderlyings &putUnderlyingSymbol(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 4, src, sizeof(char) * 20); - return *this; - } - - std::string getUnderlyingSymbolAsString() const { - const char *buffer = m_buffer + m_offset + 4; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getUnderlyingSymbolAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getUnderlyingSymbolAsString(); - - 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 getUnderlyingSymbolAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 4; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - NoUnderlyings &putUnderlyingSymbol(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putUnderlyingSymbol [E106]"); - } - - std::memcpy(m_buffer + m_offset + 4, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 4 + start] = 0; - } - - return *this; - } -#else - NoUnderlyings &putUnderlyingSymbol(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putUnderlyingSymbol [E106]"); - } - - std::memcpy(m_buffer + m_offset + 4, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 4 + start] = 0; - } - - return *this; - } -#endif - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoUnderlyings writer) { - builder << '{'; - builder << R"("UnderlyingSecurityID": )"; - builder << +writer.underlyingSecurityID(); - - builder << ", "; - builder << R"("UnderlyingSymbol": )"; - builder << '"' - << writer.getUnderlyingSymbolAsJsonEscapedString().c_str() - << '"'; - - builder << '}'; - - return builder; - } - }; - - private: - NoUnderlyings m_noUnderlyings; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoUnderlyingsId() SBE_NOEXCEPT { - return 711; - } - - SBE_NODISCARD inline NoUnderlyings &noUnderlyings() { - m_noUnderlyings.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noUnderlyings; - } - - NoUnderlyings &noUnderlyingsCount(const std::uint8_t count) { - m_noUnderlyings.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noUnderlyings; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noUnderlyingsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noUnderlyingsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noUnderlyingsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoRelatedInstruments { + class NoRelatedInstruments + { 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(24)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 24; + 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 24; + } + + 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 NoRelatedInstruments &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(static_cast(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 *RelatedSecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t relatedSecurityIDId() SBE_NOEXCEPT + { + return 1650; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t relatedSecurityIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool relatedSecurityIDInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= relatedSecurityIDSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t relatedSecurityIDEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::int32_t relatedSecurityIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t relatedSecurityIDMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t relatedSecurityIDMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t relatedSecurityIDEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t relatedSecurityID() 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); + } + + NoRelatedInstruments &relatedSecurityID(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 *RelatedSecurityIDSourceMetaAttribute(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 relatedSecurityIDSourceId() SBE_NOEXCEPT + { + return 1651; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t relatedSecurityIDSourceSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool relatedSecurityIDSourceInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= relatedSecurityIDSourceSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t relatedSecurityIDSourceEncodingOffset() SBE_NOEXCEPT + { + return 4; + } + + static SBE_CONSTEXPR char relatedSecurityIDSourceNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char relatedSecurityIDSourceMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char relatedSecurityIDSourceMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t relatedSecurityIDSourceEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::uint64_t relatedSecurityIDSourceLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD const char *relatedSecurityIDSource() const + { + static const std::uint8_t relatedSecurityIDSourceValues[] = { 56 }; + + return (const char *)relatedSecurityIDSourceValues; + } + + SBE_NODISCARD char relatedSecurityIDSource(const std::uint64_t index) const + { + static const std::uint8_t relatedSecurityIDSourceValues[] = { 56 }; + + return (char)relatedSecurityIDSourceValues[index]; + } + + std::uint64_t getRelatedSecurityIDSource(char *dst, const std::uint64_t length) const + { + static std::uint8_t relatedSecurityIDSourceValues[] = { 56 }; + std::uint64_t bytesToCopy = length < sizeof(relatedSecurityIDSourceValues) ? length : sizeof(relatedSecurityIDSourceValues); + + std::memcpy(dst, relatedSecurityIDSourceValues, static_cast(bytesToCopy)); + return bytesToCopy; + } + + std::string getRelatedSecurityIDSourceAsString() const + { + static const std::uint8_t RelatedSecurityIDSourceValues[] = { 56 }; + + return std::string((const char *)RelatedSecurityIDSourceValues, 1); + } + + std::string getRelatedSecurityIDSourceAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getRelatedSecurityIDSourceAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + 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 *RelatedSymbolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t relatedSymbolId() SBE_NOEXCEPT + { + return 1649; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t relatedSymbolSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool relatedSymbolInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= relatedSymbolSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t relatedSymbolEncodingOffset() SBE_NOEXCEPT + { + return 4; + } + + static SBE_CONSTEXPR char relatedSymbolNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char relatedSymbolMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char relatedSymbolMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t relatedSymbolEncodingLength() SBE_NOEXCEPT + { + return 20; + } + + static SBE_CONSTEXPR std::uint64_t relatedSymbolLength() SBE_NOEXCEPT + { + return 20; + } + + SBE_NODISCARD const char *relatedSymbol() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 4; + } + + SBE_NODISCARD char *relatedSymbol() SBE_NOEXCEPT + { + return m_buffer + m_offset + 4; + } + + SBE_NODISCARD char relatedSymbol(const std::uint64_t index) const + { + if (index >= 20) + { + throw std::runtime_error("index out of range for relatedSymbol [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 4 + (index * 1), sizeof(char)); + return (val); + } + + NoRelatedInstruments &relatedSymbol(const std::uint64_t index, const char value) + { + if (index >= 20) + { + throw std::runtime_error("index out of range for relatedSymbol [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 4 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getRelatedSymbol(char *const dst, const std::uint64_t length) const + { + if (length > 20) + { + throw std::runtime_error("length too large for getRelatedSymbol [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 4, sizeof(char) * static_cast(length)); + return length; + } + + NoRelatedInstruments &putRelatedSymbol(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 4, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getRelatedSymbolAsString() const + { + const char *buffer = m_buffer + m_offset + 4; + size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getRelatedSymbolAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getRelatedSymbolAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + 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 getRelatedSymbolAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 4; + size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoRelatedInstruments &putRelatedSymbol(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putRelatedSymbol [E106]"); + } + + std::memcpy(m_buffer + m_offset + 4, str.data(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 4 + start] = 0; + } + + return *this; + } + #else + NoRelatedInstruments &putRelatedSymbol(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 20) + { + throw std::runtime_error("string too large for putRelatedSymbol [E106]"); + } + + std::memcpy(m_buffer + m_offset + 4, str.c_str(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 4 + start] = 0; + } + + return *this; + } + #endif + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoRelatedInstruments writer) + { + builder << '{'; + builder << R"("RelatedSecurityID": )"; + builder << +writer.relatedSecurityID(); + + builder << ", "; + builder << R"("RelatedSymbol": )"; + builder << '"' << + writer.getRelatedSymbolAsJsonEscapedString().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 - 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)24); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 24; - 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: + NoRelatedInstruments m_noRelatedInstruments; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 24; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoRelatedInstrumentsId() SBE_NOEXCEPT + { + return 1647; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoRelatedInstruments &noRelatedInstruments() + { + m_noRelatedInstruments.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noRelatedInstruments; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoRelatedInstruments &noRelatedInstrumentsCount(const std::uint8_t count) + { + m_noRelatedInstruments.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noRelatedInstruments; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noRelatedInstrumentsSinceVersion() 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 NoRelatedInstruments &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 *RelatedSecurityIDMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t relatedSecurityIDId() SBE_NOEXCEPT { - return 1650; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - relatedSecurityIDSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool relatedSecurityIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noRelatedInstrumentsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= relatedSecurityIDSinceVersion(); + return m_actingVersion >= noRelatedInstrumentsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - relatedSecurityIDEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int32_t - relatedSecurityIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t - relatedSecurityIDMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t - relatedSecurityIDMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - relatedSecurityIDEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t relatedSecurityID() 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); - } - - NoRelatedInstruments & - relatedSecurityID(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 *RelatedSecurityIDSourceMetaAttribute( - 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 - relatedSecurityIDSourceId() SBE_NOEXCEPT { - return 1651; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - relatedSecurityIDSourceSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool relatedSecurityIDSourceInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= relatedSecurityIDSourceSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - relatedSecurityIDSourceEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR char - relatedSecurityIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char relatedSecurityIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char relatedSecurityIDSourceMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - relatedSecurityIDSourceEncodingLength() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::uint64_t - relatedSecurityIDSourceLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD const char *relatedSecurityIDSource() const { - static const std::uint8_t relatedSecurityIDSourceValues[] = {56}; - - return (const char *)relatedSecurityIDSourceValues; - } - - SBE_NODISCARD char - relatedSecurityIDSource(const std::uint64_t index) const { - static const std::uint8_t relatedSecurityIDSourceValues[] = {56}; - - return (char)relatedSecurityIDSourceValues[index]; - } - - std::uint64_t - getRelatedSecurityIDSource(char *dst, const std::uint64_t length) const { - static std::uint8_t relatedSecurityIDSourceValues[] = {56}; - std::uint64_t bytesToCopy = - length < sizeof(relatedSecurityIDSourceValues) - ? length - : sizeof(relatedSecurityIDSourceValues); - - std::memcpy( - dst, relatedSecurityIDSourceValues, - static_cast(bytesToCopy)); - return bytesToCopy; - } - - std::string getRelatedSecurityIDSourceAsString() const { - static const std::uint8_t RelatedSecurityIDSourceValues[] = {56}; - - return std::string((const char *)RelatedSecurityIDSourceValues, 1); - } - - std::string getRelatedSecurityIDSourceAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getRelatedSecurityIDSourceAsString(); - - 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 *RelatedSymbolMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t relatedSymbolId() SBE_NOEXCEPT { - return 1649; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - relatedSymbolSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool relatedSymbolInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= relatedSymbolSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - relatedSymbolEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - static SBE_CONSTEXPR char relatedSymbolNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char relatedSymbolMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char relatedSymbolMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t - relatedSymbolEncodingLength() SBE_NOEXCEPT { - return 20; - } - - static SBE_CONSTEXPR std::uint64_t relatedSymbolLength() SBE_NOEXCEPT { - return 20; - } - - SBE_NODISCARD const char *relatedSymbol() const SBE_NOEXCEPT { - return m_buffer + m_offset + 4; - } - - SBE_NODISCARD char *relatedSymbol() SBE_NOEXCEPT { - return m_buffer + m_offset + 4; - } - - SBE_NODISCARD char relatedSymbol(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error( - "index out of range for relatedSymbol [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 4 + (index * 1), sizeof(char)); - return (val); - } - - NoRelatedInstruments & - relatedSymbol(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error( - "index out of range for relatedSymbol [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 4 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getRelatedSymbol(char *const dst, const std::uint64_t length) const { - if (length > 20) { - throw std::runtime_error( - "length too large for getRelatedSymbol [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 4, - sizeof(char) * static_cast(length)); - return length; - } - - NoRelatedInstruments & - putRelatedSymbol(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 4, src, sizeof(char) * 20); - return *this; - } - - std::string getRelatedSymbolAsString() const { - const char *buffer = m_buffer + m_offset + 4; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getRelatedSymbolAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getRelatedSymbolAsString(); - - 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 getRelatedSymbolAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 4; - size_t length = 0; - - for (; length < 20 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - NoRelatedInstruments &putRelatedSymbol(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putRelatedSymbol [E106]"); - } - - std::memcpy(m_buffer + m_offset + 4, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 4 + start] = 0; - } - - return *this; - } -#else - NoRelatedInstruments &putRelatedSymbol(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error( - "string too large for putRelatedSymbol [E106]"); - } - - std::memcpy(m_buffer + m_offset + 4, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 4 + start] = 0; - } - - return *this; - } -#endif - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - NoRelatedInstruments writer) { - builder << '{'; - builder << R"("RelatedSecurityID": )"; - builder << +writer.relatedSecurityID(); - - builder << ", "; - builder << R"("RelatedSymbol": )"; - builder << '"' << writer.getRelatedSymbolAsJsonEscapedString().c_str() - << '"'; - - builder << '}'; - - return builder; - } - }; - - private: - NoRelatedInstruments m_noRelatedInstruments; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoRelatedInstrumentsId() SBE_NOEXCEPT { - return 1647; - } - - SBE_NODISCARD inline NoRelatedInstruments &noRelatedInstruments() { - m_noRelatedInstruments.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noRelatedInstruments; - } - - NoRelatedInstruments &noRelatedInstrumentsCount(const std::uint8_t count) { - m_noRelatedInstruments.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noRelatedInstruments; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noRelatedInstrumentsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noRelatedInstrumentsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noRelatedInstrumentsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDInstrumentDefinitionOption55 _writer) { - MDInstrumentDefinitionOption55 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDInstrumentDefinitionOption55", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); - - builder << ", "; - builder << R"("TotNumReports": )"; - builder << +writer.totNumReports(); - - builder << ", "; - builder << R"("SecurityUpdateAction": )"; - builder << '"' << writer.securityUpdateAction() << '"'; - - builder << ", "; - builder << R"("LastUpdateTime": )"; - builder << +writer.lastUpdateTime(); - - builder << ", "; - builder << R"("MDSecurityTradingStatus": )"; - builder << '"' << writer.mDSecurityTradingStatus() << '"'; - - builder << ", "; - builder << R"("ApplID": )"; - builder << +writer.applID(); - - builder << ", "; - builder << R"("MarketSegmentID": )"; - builder << +writer.marketSegmentID(); - - builder << ", "; - builder << R"("UnderlyingProduct": )"; - builder << +writer.underlyingProduct(); - - builder << ", "; - builder << R"("SecurityExchange": )"; - builder << '"' << writer.getSecurityExchangeAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("SecurityGroup": )"; - builder << '"' << writer.getSecurityGroupAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("Asset": )"; - builder << '"' << writer.getAssetAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("Symbol": )"; - builder << '"' << writer.getSymbolAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("SecurityType": )"; - builder << '"' << writer.getSecurityTypeAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("CFICode": )"; - builder << '"' << writer.getCFICodeAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("PutOrCall": )"; - builder << '"' << writer.putOrCall() << '"'; - - builder << ", "; - builder << R"("MaturityMonthYear": )"; - builder << writer.maturityMonthYear(); - - builder << ", "; - builder << R"("Currency": )"; - builder << '"' << writer.getCurrencyAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("StrikePrice": )"; - builder << writer.strikePrice(); - - builder << ", "; - builder << R"("StrikeCurrency": )"; - builder << '"' << writer.getStrikeCurrencyAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("SettlCurrency": )"; - builder << '"' << writer.getSettlCurrencyAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("MinCabPrice": )"; - builder << writer.minCabPrice(); - - builder << ", "; - builder << R"("MatchAlgorithm": )"; - if (std::isprint(writer.matchAlgorithm())) { - builder << '"' << (char)writer.matchAlgorithm() << '"'; - } else { - builder << (int)writer.matchAlgorithm(); - } - - builder << ", "; - builder << R"("MinTradeVol": )"; - builder << +writer.minTradeVol(); - - builder << ", "; - builder << R"("MaxTradeVol": )"; - builder << +writer.maxTradeVol(); - - builder << ", "; - builder << R"("MinPriceIncrement": )"; - builder << writer.minPriceIncrement(); - - builder << ", "; - builder << R"("MinPriceIncrementAmount": )"; - builder << writer.minPriceIncrementAmount(); - - builder << ", "; - builder << R"("DisplayFactor": )"; - builder << writer.displayFactor(); - - builder << ", "; - builder << R"("TickRule": )"; - builder << +writer.tickRule(); - - builder << ", "; - builder << R"("MainFraction": )"; - builder << +writer.mainFraction(); - - builder << ", "; - builder << R"("SubFraction": )"; - builder << +writer.subFraction(); - - builder << ", "; - builder << R"("PriceDisplayFormat": )"; - builder << +writer.priceDisplayFormat(); - - builder << ", "; - builder << R"("UnitOfMeasure": )"; - builder << '"' << writer.getUnitOfMeasureAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("UnitOfMeasureQty": )"; - builder << writer.unitOfMeasureQty(); - - builder << ", "; - builder << R"("TradingReferencePrice": )"; - builder << writer.tradingReferencePrice(); - - builder << ", "; - builder << R"("SettlPriceType": )"; - builder << writer.settlPriceType(); - - builder << ", "; - builder << R"("ClearedVolume": )"; - builder << +writer.clearedVolume(); - - builder << ", "; - builder << R"("OpenInterestQty": )"; - builder << +writer.openInterestQty(); - - builder << ", "; - builder << R"("LowLimitPrice": )"; - builder << writer.lowLimitPrice(); - - builder << ", "; - builder << R"("HighLimitPrice": )"; - builder << writer.highLimitPrice(); - - builder << ", "; - builder << R"("UserDefinedInstrument": )"; - if (std::isprint(writer.userDefinedInstrument())) { - builder << '"' << (char)writer.userDefinedInstrument() << '"'; - } else { - builder << (int)writer.userDefinedInstrument(); - } - - builder << ", "; - builder << R"("TradingReferenceDate": )"; - builder << +writer.tradingReferenceDate(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoEvents": [)"; - writer.noEvents().forEach([&](NoEvents &noEvents) { - if (atLeastOne) { - builder << ", "; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDInstrumentDefinitionOption55 _writer) +{ + MDInstrumentDefinitionOption55 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDInstrumentDefinitionOption55", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); + + builder << ", "; + builder << R"("TotNumReports": )"; + builder << +writer.totNumReports(); + + builder << ", "; + builder << R"("SecurityUpdateAction": )"; + builder << '"' << writer.securityUpdateAction() << '"'; + + builder << ", "; + builder << R"("LastUpdateTime": )"; + builder << +writer.lastUpdateTime(); + + builder << ", "; + builder << R"("MDSecurityTradingStatus": )"; + builder << '"' << writer.mDSecurityTradingStatus() << '"'; + + builder << ", "; + builder << R"("ApplID": )"; + builder << +writer.applID(); + + builder << ", "; + builder << R"("MarketSegmentID": )"; + builder << +writer.marketSegmentID(); + + builder << ", "; + builder << R"("UnderlyingProduct": )"; + builder << +writer.underlyingProduct(); + + builder << ", "; + builder << R"("SecurityExchange": )"; + builder << '"' << + writer.getSecurityExchangeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityGroup": )"; + builder << '"' << + writer.getSecurityGroupAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("Asset": )"; + builder << '"' << + writer.getAssetAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("Symbol": )"; + builder << '"' << + writer.getSymbolAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("SecurityType": )"; + builder << '"' << + writer.getSecurityTypeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("CFICode": )"; + builder << '"' << + writer.getCFICodeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("PutOrCall": )"; + builder << '"' << writer.putOrCall() << '"'; + + builder << ", "; + builder << R"("MaturityMonthYear": )"; + builder << writer.maturityMonthYear(); + + builder << ", "; + builder << R"("Currency": )"; + builder << '"' << + writer.getCurrencyAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("StrikePrice": )"; + builder << writer.strikePrice(); + + builder << ", "; + builder << R"("StrikeCurrency": )"; + builder << '"' << + writer.getStrikeCurrencyAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SettlCurrency": )"; + builder << '"' << + writer.getSettlCurrencyAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("MinCabPrice": )"; + builder << writer.minCabPrice(); + + builder << ", "; + builder << R"("MatchAlgorithm": )"; + if (std::isprint(writer.matchAlgorithm())) + { + builder << '"' << (char)writer.matchAlgorithm() << '"'; + } + else + { + builder << (int)writer.matchAlgorithm(); + } + + builder << ", "; + builder << R"("MinTradeVol": )"; + builder << +writer.minTradeVol(); + + builder << ", "; + builder << R"("MaxTradeVol": )"; + builder << +writer.maxTradeVol(); + + builder << ", "; + builder << R"("MinPriceIncrement": )"; + builder << writer.minPriceIncrement(); + + builder << ", "; + builder << R"("MinPriceIncrementAmount": )"; + builder << writer.minPriceIncrementAmount(); + + builder << ", "; + builder << R"("DisplayFactor": )"; + builder << writer.displayFactor(); + + builder << ", "; + builder << R"("TickRule": )"; + builder << +writer.tickRule(); + + builder << ", "; + builder << R"("MainFraction": )"; + builder << +writer.mainFraction(); + + builder << ", "; + builder << R"("SubFraction": )"; + builder << +writer.subFraction(); + + builder << ", "; + builder << R"("PriceDisplayFormat": )"; + builder << +writer.priceDisplayFormat(); + + builder << ", "; + builder << R"("UnitOfMeasure": )"; + builder << '"' << + writer.getUnitOfMeasureAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("UnitOfMeasureQty": )"; + builder << writer.unitOfMeasureQty(); + + builder << ", "; + builder << R"("TradingReferencePrice": )"; + builder << writer.tradingReferencePrice(); + + builder << ", "; + builder << R"("SettlPriceType": )"; + builder << writer.settlPriceType(); + + builder << ", "; + builder << R"("ClearedVolume": )"; + builder << +writer.clearedVolume(); + + builder << ", "; + builder << R"("OpenInterestQty": )"; + builder << +writer.openInterestQty(); + + builder << ", "; + builder << R"("LowLimitPrice": )"; + builder << writer.lowLimitPrice(); + + builder << ", "; + builder << R"("HighLimitPrice": )"; + builder << writer.highLimitPrice(); + + builder << ", "; + builder << R"("UserDefinedInstrument": )"; + if (std::isprint(writer.userDefinedInstrument())) + { + builder << '"' << (char)writer.userDefinedInstrument() << '"'; + } + else + { + builder << (int)writer.userDefinedInstrument(); + } + + builder << ", "; + builder << R"("TradingReferenceDate": )"; + builder << +writer.tradingReferenceDate(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoEvents": [)"; + writer.noEvents().forEach([&](NoEvents& noEvents) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noEvents; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDFeedTypes": [)"; - writer.noMDFeedTypes().forEach([&](NoMDFeedTypes &noMDFeedTypes) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDFeedTypes": [)"; + writer.noMDFeedTypes().forEach([&](NoMDFeedTypes& noMDFeedTypes) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDFeedTypes; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoInstAttrib": [)"; - writer.noInstAttrib().forEach([&](NoInstAttrib &noInstAttrib) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoInstAttrib": [)"; + writer.noInstAttrib().forEach([&](NoInstAttrib& noInstAttrib) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noInstAttrib; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoLotTypeRules": [)"; - writer.noLotTypeRules().forEach([&](NoLotTypeRules &noLotTypeRules) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoLotTypeRules": [)"; + writer.noLotTypeRules().forEach([&](NoLotTypeRules& noLotTypeRules) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noLotTypeRules; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoUnderlyings": [)"; - writer.noUnderlyings().forEach([&](NoUnderlyings &noUnderlyings) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoUnderlyings": [)"; + writer.noUnderlyings().forEach([&](NoUnderlyings& noUnderlyings) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noUnderlyings; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoRelatedInstruments": [)"; - writer.noRelatedInstruments().forEach( - [&](NoRelatedInstruments &noRelatedInstruments) { - if (atLeastOne) { - builder << ", "; - } - atLeastOne = true; - builder << noRelatedInstruments; - }); - builder << ']'; - } + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoRelatedInstruments": [)"; + writer.noRelatedInstruments().forEach([&](NoRelatedInstruments& noRelatedInstruments) + { + if (atLeastOne) + { + builder << ", "; + } + atLeastOne = true; + builder << noRelatedInstruments; + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noEvents().forEach([](NoEvents e) + { + e.skip(); + }); + noMDFeedTypes().forEach([](NoMDFeedTypes e) + { + e.skip(); + }); + noInstAttrib().forEach([](NoInstAttrib e) + { + e.skip(); + }); + noLotTypeRules().forEach([](NoLotTypeRules e) + { + e.skip(); + }); + noUnderlyings().forEach([](NoUnderlyings e) + { + e.skip(); + }); + noRelatedInstruments().forEach([](NoRelatedInstruments e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noEventsLength = 0, + std::size_t noMDFeedTypesLength = 0, + std::size_t noInstAttribLength = 0, + std::size_t noLotTypeRulesLength = 0, + std::size_t noUnderlyingsLength = 0, + std::size_t noRelatedInstrumentsLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoEvents::sbeHeaderSize(); + if (noEventsLength > 254LL) + { + throw std::runtime_error("noEventsLength outside of allowed range [E110]"); + } + length += noEventsLength *NoEvents::sbeBlockLength(); + + length += NoMDFeedTypes::sbeHeaderSize(); + if (noMDFeedTypesLength > 254LL) + { + throw std::runtime_error("noMDFeedTypesLength outside of allowed range [E110]"); + } + length += noMDFeedTypesLength *NoMDFeedTypes::sbeBlockLength(); + + length += NoInstAttrib::sbeHeaderSize(); + if (noInstAttribLength > 254LL) + { + throw std::runtime_error("noInstAttribLength outside of allowed range [E110]"); + } + length += noInstAttribLength *NoInstAttrib::sbeBlockLength(); + + length += NoLotTypeRules::sbeHeaderSize(); + if (noLotTypeRulesLength > 254LL) + { + throw std::runtime_error("noLotTypeRulesLength outside of allowed range [E110]"); + } + length += noLotTypeRulesLength *NoLotTypeRules::sbeBlockLength(); + + length += NoUnderlyings::sbeHeaderSize(); + if (noUnderlyingsLength > 254LL) + { + throw std::runtime_error("noUnderlyingsLength outside of allowed range [E110]"); + } + length += noUnderlyingsLength *NoUnderlyings::sbeBlockLength(); + + length += NoRelatedInstruments::sbeHeaderSize(); + if (noRelatedInstrumentsLength > 254LL) + { + throw std::runtime_error("noRelatedInstrumentsLength outside of allowed range [E110]"); + } + length += noRelatedInstrumentsLength *NoRelatedInstruments::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionSpread29.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionSpread29.h index 9196149db..057957e33 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionSpread29.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionSpread29.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,6083 +86,6650 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDInstrumentDefinitionSpread29 { - 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 MDInstrumentDefinitionSpread29 +{ +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; } + 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(195); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(29); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDInstrumentDefinitionSpread29() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDInstrumentDefinitionSpread29( - 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; - MDInstrumentDefinitionSpread29( - char *buffer, const std::uint64_t bufferLength) - : MDInstrumentDefinitionSpread29( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDInstrumentDefinitionSpread29() = default; - MDInstrumentDefinitionSpread29( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDInstrumentDefinitionSpread29( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDInstrumentDefinitionSpread29( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)195; - } + MDInstrumentDefinitionSpread29(char *buffer, const std::uint64_t bufferLength) : + MDInstrumentDefinitionSpread29(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)29; - } + MDInstrumentDefinitionSpread29( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDInstrumentDefinitionSpread29(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(195); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "d"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(29); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDInstrumentDefinitionSpread29 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDInstrumentDefinitionSpread29( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDInstrumentDefinitionSpread29 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "d"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDInstrumentDefinitionSpread29( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDInstrumentDefinitionSpread29 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDInstrumentDefinitionSpread29(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDInstrumentDefinitionSpread29 &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 = MDInstrumentDefinitionSpread29( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDInstrumentDefinitionSpread29 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDInstrumentDefinitionSpread29( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDInstrumentDefinitionSpread29 &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 = MDInstrumentDefinitionSpread29(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MDInstrumentDefinitionSpread29 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char *MatchEventIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MultipleCharValue"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char * - TotNumReportsMetaAttribute(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 *TotNumReportsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT { - return 911; - } + static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT + { + return 911; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totNumReportsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t totNumReportsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= totNumReportsSinceVersion(); + return m_actingVersion >= totNumReportsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totNumReportsEncodingOffset() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t totNumReportsEncodingOffset() SBE_NOEXCEPT + { + return 1; + } - static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t totNumReports() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t totNumReports() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionSpread29 & - totNumReports(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint32_t)); - return *this; - } + MDInstrumentDefinitionSpread29 &totNumReports(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char *SecurityUpdateActionMetaAttribute( - 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 *SecurityUpdateActionMetaAttribute(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 securityUpdateActionId() SBE_NOEXCEPT { - return 980; - } + static SBE_CONSTEXPR std::uint16_t securityUpdateActionId() SBE_NOEXCEPT + { + return 980; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityUpdateActionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityUpdateActionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityUpdateActionSinceVersion(); + return m_actingVersion >= securityUpdateActionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SecurityUpdateAction::Value - securityUpdateAction() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 5, sizeof(char)); - return SecurityUpdateAction::get((val)); - } + SBE_NODISCARD SecurityUpdateAction::Value securityUpdateAction() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 5, sizeof(char)); + return SecurityUpdateAction::get((val)); + } - MDInstrumentDefinitionSpread29 & - securityUpdateAction(const SecurityUpdateAction::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 5, &val, sizeof(char)); - return *this; - } + MDInstrumentDefinitionSpread29 &securityUpdateAction(const SecurityUpdateAction::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 5, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char * - LastUpdateTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LastUpdateTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t lastUpdateTimeId() SBE_NOEXCEPT { - return 779; - } + static SBE_CONSTEXPR std::uint16_t lastUpdateTimeId() SBE_NOEXCEPT + { + return 779; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastUpdateTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastUpdateTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lastUpdateTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lastUpdateTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastUpdateTimeSinceVersion(); + return m_actingVersion >= lastUpdateTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastUpdateTimeEncodingOffset() SBE_NOEXCEPT { - return 6; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastUpdateTimeEncodingOffset() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - lastUpdateTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t lastUpdateTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t lastUpdateTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 6, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t lastUpdateTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 6, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MDInstrumentDefinitionSpread29 & - lastUpdateTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 6, &val, sizeof(std::uint64_t)); - return *this; - } + MDInstrumentDefinitionSpread29 &lastUpdateTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 6, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *MDSecurityTradingStatusMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MDSecurityTradingStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mDSecurityTradingStatusId() SBE_NOEXCEPT { - return 1682; - } + static SBE_CONSTEXPR std::uint16_t mDSecurityTradingStatusId() SBE_NOEXCEPT + { + return 1682; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDSecurityTradingStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDSecurityTradingStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mDSecurityTradingStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mDSecurityTradingStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDSecurityTradingStatusSinceVersion(); + return m_actingVersion >= mDSecurityTradingStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDSecurityTradingStatusEncodingOffset() SBE_NOEXCEPT { - return 14; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDSecurityTradingStatusEncodingOffset() SBE_NOEXCEPT + { + return 14; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDSecurityTradingStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDSecurityTradingStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SecurityTradingStatus::Value - mDSecurityTradingStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); - return SecurityTradingStatus::get((val)); - } + SBE_NODISCARD SecurityTradingStatus::Value mDSecurityTradingStatus() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); + return SecurityTradingStatus::get((val)); + } - MDInstrumentDefinitionSpread29 &mDSecurityTradingStatus( - const SecurityTradingStatus::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionSpread29 &mDSecurityTradingStatus(const SecurityTradingStatus::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - ApplIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ApplIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t applIDId() SBE_NOEXCEPT { return 1180; } + static SBE_CONSTEXPR std::uint16_t applIDId() SBE_NOEXCEPT + { + return 1180; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - applIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t applIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool applIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool applIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= applIDSinceVersion(); + return m_actingVersion >= applIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - applIDEncodingOffset() SBE_NOEXCEPT { - return 15; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t applIDEncodingOffset() SBE_NOEXCEPT + { + return 15; + } - static SBE_CONSTEXPR std::int16_t applIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT16; - } + static SBE_CONSTEXPR std::int16_t applIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT16; + } - static SBE_CONSTEXPR std::int16_t applIDMinValue() SBE_NOEXCEPT { - return (std::int16_t)-32767; - } + static SBE_CONSTEXPR std::int16_t applIDMinValue() SBE_NOEXCEPT + { + return static_cast(-32767); + } - static SBE_CONSTEXPR std::int16_t applIDMaxValue() SBE_NOEXCEPT { - return (std::int16_t)32767; - } + static SBE_CONSTEXPR std::int16_t applIDMaxValue() SBE_NOEXCEPT + { + return static_cast(32767); + } - static SBE_CONSTEXPR std::size_t applIDEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t applIDEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::int16_t applID() const SBE_NOEXCEPT { - std::int16_t val; - std::memcpy(&val, m_buffer + m_offset + 15, sizeof(std::int16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::int16_t applID() const SBE_NOEXCEPT + { + std::int16_t val; + std::memcpy(&val, m_buffer + m_offset + 15, sizeof(std::int16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - MDInstrumentDefinitionSpread29 & - applID(const std::int16_t value) SBE_NOEXCEPT { - std::int16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 15, &val, sizeof(std::int16_t)); - return *this; - } + MDInstrumentDefinitionSpread29 &applID(const std::int16_t value) SBE_NOEXCEPT + { + std::int16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 15, &val, sizeof(std::int16_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 "required"; - 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 "required"; + 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 17; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t marketSegmentIDEncodingOffset() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } - 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 + 17, 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 + 17, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionSpread29 & - marketSegmentID(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionSpread29 &marketSegmentID(const std::uint8_t 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 *UnderlyingProductMetaAttribute( - 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 *UnderlyingProductMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t underlyingProductId() SBE_NOEXCEPT { - return 462; - } + static SBE_CONSTEXPR std::uint16_t underlyingProductId() SBE_NOEXCEPT + { + return 462; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - underlyingProductSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t underlyingProductSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool underlyingProductInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool underlyingProductInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= underlyingProductSinceVersion(); + return m_actingVersion >= underlyingProductSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - underlyingProductEncodingOffset() SBE_NOEXCEPT { - return 18; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t underlyingProductEncodingOffset() SBE_NOEXCEPT + { + return 18; + } - static SBE_CONSTEXPR std::uint8_t underlyingProductNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t underlyingProductNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t underlyingProductMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t underlyingProductMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t underlyingProductMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t underlyingProductMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - underlyingProductEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t underlyingProductEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t underlyingProduct() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t underlyingProduct() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionSpread29 & - underlyingProduct(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; - } + MDInstrumentDefinitionSpread29 &underlyingProduct(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 static const char *SecurityExchangeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Exchange"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityExchangeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Exchange"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityExchangeId() SBE_NOEXCEPT { - return 207; - } + static SBE_CONSTEXPR std::uint16_t securityExchangeId() SBE_NOEXCEPT + { + return 207; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityExchangeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityExchangeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityExchangeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityExchangeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityExchangeSinceVersion(); + return m_actingVersion >= securityExchangeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityExchangeEncodingOffset() SBE_NOEXCEPT { - return 19; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityExchangeEncodingOffset() SBE_NOEXCEPT + { + return 19; + } - static SBE_CONSTEXPR char securityExchangeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityExchangeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityExchangeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityExchangeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityExchangeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char securityExchangeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - securityExchangeEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityExchangeEncodingLength() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t securityExchangeLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::uint64_t securityExchangeLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD const char *securityExchange() const SBE_NOEXCEPT { - return m_buffer + m_offset + 19; - } + SBE_NODISCARD const char *securityExchange() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 19; + } - SBE_NODISCARD char *securityExchange() SBE_NOEXCEPT { - return m_buffer + m_offset + 19; - } + SBE_NODISCARD char *securityExchange() SBE_NOEXCEPT + { + return m_buffer + m_offset + 19; + } - SBE_NODISCARD char securityExchange(const std::uint64_t index) const { - if (index >= 4) { - throw std::runtime_error( - "index out of range for securityExchange [E104]"); - } + SBE_NODISCARD char securityExchange(const std::uint64_t index) const + { + if (index >= 4) + { + throw std::runtime_error("index out of range for securityExchange [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 19 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 19 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread29 & - securityExchange(const std::uint64_t index, const char value) { - if (index >= 4) { - throw std::runtime_error( - "index out of range for securityExchange [E105]"); - } + MDInstrumentDefinitionSpread29 &securityExchange(const std::uint64_t index, const char value) + { + if (index >= 4) + { + throw std::runtime_error("index out of range for securityExchange [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 19 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 19 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSecurityExchange(char *const dst, const std::uint64_t length) const { - if (length > 4) { - throw std::runtime_error( - "length too large for getSecurityExchange [E106]"); - } + std::uint64_t getSecurityExchange(char *const dst, const std::uint64_t length) const + { + if (length > 4) + { + throw std::runtime_error("length too large for getSecurityExchange [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 19, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 19, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionSpread29 & - putSecurityExchange(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 19, src, sizeof(char) * 4); - return *this; - } + MDInstrumentDefinitionSpread29 &putSecurityExchange(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 19, src, sizeof(char) * 4); + return *this; + } - MDInstrumentDefinitionSpread29 &putSecurityExchange( - const char value0, - const char value1, - const char value2, - const char value3) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 19, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 20, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 21, &val2, sizeof(char)); - char val3 = (value3); - std::memcpy(m_buffer + m_offset + 22, &val3, sizeof(char)); + MDInstrumentDefinitionSpread29 &putSecurityExchange( + const char value0, + const char value1, + const char value2, + const char value3) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 19, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 20, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 21, &val2, sizeof(char)); + char val3 = (value3); + std::memcpy(m_buffer + m_offset + 22, &val3, sizeof(char)); - return *this; - } + return *this; + } - std::string getSecurityExchangeAsString() const { - const char *buffer = m_buffer + m_offset + 19; - size_t length = 0; + SBE_NODISCARD std::string getSecurityExchangeAsString() const + { + const char *buffer = m_buffer + m_offset + 19; + size_t length = 0; - for (; length < 4 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 4 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSecurityExchangeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityExchangeAsString(); + std::string getSecurityExchangeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityExchangeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityExchangeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 19; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityExchangeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 19; + size_t length = 0; - for (; length < 4 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 4 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - MDInstrumentDefinitionSpread29 & - putSecurityExchange(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 4) { - throw std::runtime_error( - "string too large for putSecurityExchange [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionSpread29 &putSecurityExchange(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 4) + { + throw std::runtime_error("string too large for putSecurityExchange [E106]"); + } - std::memcpy(m_buffer + m_offset + 19, str.data(), srcLength); - for (size_t start = srcLength; start < 4; ++start) { - m_buffer[m_offset + 19 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 19, str.data(), srcLength); + for (size_t start = srcLength; start < 4; ++start) + { + m_buffer[m_offset + 19 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionSpread29 &putSecurityExchange(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 4) { - throw std::runtime_error( - "string too large for putSecurityExchange [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionSpread29 &putSecurityExchange(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 4) + { + throw std::runtime_error("string too large for putSecurityExchange [E106]"); + } - std::memcpy(m_buffer + m_offset + 19, str.c_str(), srcLength); - for (size_t start = srcLength; start < 4; ++start) { - m_buffer[m_offset + 19 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 19, str.c_str(), srcLength); + for (size_t start = srcLength; start < 4; ++start) + { + m_buffer[m_offset + 19 + start] = 0; + } - return *this; - } -#endif + return *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 "required"; - 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 "required"; + 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 23; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityGroupEncodingOffset() SBE_NOEXCEPT + { + return 23; + } - 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 + 23; - } + SBE_NODISCARD const char *securityGroup() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 23; + } - SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT { - return m_buffer + m_offset + 23; - } + SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT + { + return m_buffer + m_offset + 23; + } - 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 + 23 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 23 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread29 & - securityGroup(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E105]"); - } + MDInstrumentDefinitionSpread29 &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 + 23 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 23 + (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 + 23, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 23, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionSpread29 & - putSecurityGroup(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 23, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionSpread29 &putSecurityGroup(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 23, src, sizeof(char) * 6); + return *this; + } - std::string getSecurityGroupAsString() const { - const char *buffer = m_buffer + m_offset + 23; - size_t length = 0; + SBE_NODISCARD std::string getSecurityGroupAsString() const + { + const char *buffer = m_buffer + m_offset + 23; + 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 (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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityGroupAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 23; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 23; + 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 - MDInstrumentDefinitionSpread29 & - 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 + MDInstrumentDefinitionSpread29 &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 + 23, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 23 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 23, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 23 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionSpread29 &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 + MDInstrumentDefinitionSpread29 &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 + 23, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 23 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 23, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 23 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - AssetMetaAttribute(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 *AssetMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t assetId() SBE_NOEXCEPT { return 6937; } + static SBE_CONSTEXPR std::uint16_t assetId() SBE_NOEXCEPT + { + return 6937; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - assetSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t assetSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool assetInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool assetInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= assetSinceVersion(); + return m_actingVersion >= assetSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - assetEncodingOffset() SBE_NOEXCEPT { - return 29; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t assetEncodingOffset() SBE_NOEXCEPT + { + return 29; + } - static SBE_CONSTEXPR char assetNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char assetNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char assetMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char assetMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char assetMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char assetMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t assetEncodingLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::size_t assetEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t assetLength() SBE_NOEXCEPT { return 6; } + static SBE_CONSTEXPR std::uint64_t assetLength() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD const char *asset() const SBE_NOEXCEPT { - return m_buffer + m_offset + 29; - } + SBE_NODISCARD const char *asset() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 29; + } - SBE_NODISCARD char *asset() SBE_NOEXCEPT { return m_buffer + m_offset + 29; } + SBE_NODISCARD char *asset() SBE_NOEXCEPT + { + return m_buffer + m_offset + 29; + } - SBE_NODISCARD char asset(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for asset [E104]"); - } + SBE_NODISCARD char asset(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for asset [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 29 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 29 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread29 & - asset(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for asset [E105]"); - } + MDInstrumentDefinitionSpread29 &asset(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for asset [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 29 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 29 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getAsset(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error("length too large for getAsset [E106]"); - } + std::uint64_t getAsset(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getAsset [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 29, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 29, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionSpread29 & - putAsset(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 29, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionSpread29 &putAsset(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 29, src, sizeof(char) * 6); + return *this; + } - std::string getAssetAsString() const { - const char *buffer = m_buffer + m_offset + 29; - size_t length = 0; + SBE_NODISCARD std::string getAssetAsString() const + { + const char *buffer = m_buffer + m_offset + 29; + 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 getAssetAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getAssetAsString(); + std::string getAssetAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getAssetAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getAssetAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 29; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getAssetAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 29; + 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 - MDInstrumentDefinitionSpread29 &putAsset(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putAsset [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionSpread29 &putAsset(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putAsset [E106]"); + } - std::memcpy(m_buffer + m_offset + 29, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 29 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 29, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 29 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionSpread29 &putAsset(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putAsset [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionSpread29 &putAsset(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putAsset [E106]"); + } - std::memcpy(m_buffer + m_offset + 29, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 29 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 29, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 29 + start] = 0; + } - return *this; - } -#endif + 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 "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SymbolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t symbolId() SBE_NOEXCEPT { return 55; } + 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 static SBE_CONSTEXPR std::uint64_t symbolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool symbolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool symbolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= symbolSinceVersion(); + return m_actingVersion >= symbolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - symbolEncodingOffset() SBE_NOEXCEPT { - return 35; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t symbolEncodingOffset() SBE_NOEXCEPT + { + return 35; + } - static SBE_CONSTEXPR char symbolNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char symbolNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char symbolMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char symbolMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char symbolMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char symbolMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t symbolEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t symbolEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t symbolLength() 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 + 35; - } + SBE_NODISCARD const char *symbol() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 35; + } - SBE_NODISCARD char *symbol() SBE_NOEXCEPT { - return m_buffer + m_offset + 35; - } + SBE_NODISCARD char *symbol() SBE_NOEXCEPT + { + return m_buffer + m_offset + 35; + } - SBE_NODISCARD char symbol(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for symbol [E104]"); - } + 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 + 35 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 35 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread29 & - symbol(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for symbol [E105]"); - } + MDInstrumentDefinitionSpread29 &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 + 35 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 35 + (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::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 + 35, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 35, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionSpread29 & - putSymbol(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 35, src, sizeof(char) * 20); - return *this; - } + MDInstrumentDefinitionSpread29 &putSymbol(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 35, src, sizeof(char) * 20); + return *this; + } - std::string getSymbolAsString() const { - const char *buffer = m_buffer + m_offset + 35; - size_t length = 0; + SBE_NODISCARD std::string getSymbolAsString() const + { + const char *buffer = m_buffer + m_offset + 35; + 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 getSymbolAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSymbolAsString(); + std::string getSymbolAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSymbolAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSymbolAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 35; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSymbolAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 35; + 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 - MDInstrumentDefinitionSpread29 &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]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionSpread29 &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 + 35, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 35 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 35, str.data(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 35 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionSpread29 &putSymbol(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSymbol [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionSpread29 &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 + 35, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 35 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 35, str.c_str(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 35 + 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 55; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 55; + } - 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 + 55, 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 + 55, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionSpread29 & - securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 55, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionSpread29 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 55, &val, sizeof(std::int32_t)); + return *this; + } - 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 ""; - } - } + 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; - } + 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 static SBE_CONSTEXPR std::uint64_t securityIDSourceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDSourceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDSourceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSourceSinceVersion(); + return m_actingVersion >= securityIDSourceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDSourceEncodingOffset() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDSourceEncodingOffset() SBE_NOEXCEPT + { + return 59; + } - static SBE_CONSTEXPR char securityIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityIDSourceNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityIDSourceMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityIDSourceMaxValue() SBE_NOEXCEPT { - return (char)126; - } + 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::size_t securityIDSourceEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t securityIDSourceLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t securityIDSourceLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *securityIDSource() const { - static const std::uint8_t securityIDSourceValues[] = {56}; + SBE_NODISCARD const char *securityIDSource() const + { + static const std::uint8_t securityIDSourceValues[] = { 56 }; - return (const char *)securityIDSourceValues; - } + return (const char *)securityIDSourceValues; + } - SBE_NODISCARD char securityIDSource(const std::uint64_t index) const { - static const std::uint8_t securityIDSourceValues[] = {56}; + SBE_NODISCARD char securityIDSource(const std::uint64_t index) const + { + static const std::uint8_t securityIDSourceValues[] = { 56 }; - return (char)securityIDSourceValues[index]; - } + 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::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::memcpy(dst, securityIDSourceValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getSecurityIDSourceAsString() const { - static const std::uint8_t SecurityIDSourceValues[] = {56}; + std::string getSecurityIDSourceAsString() const + { + static const std::uint8_t SecurityIDSourceValues[] = { 56 }; - return std::string((const char *)SecurityIDSourceValues, 1); - } + return std::string((const char *)SecurityIDSourceValues, 1); + } - std::string getSecurityIDSourceAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityIDSourceAsString(); + std::string getSecurityIDSourceAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityIDSourceAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 * - SecurityTypeMetaAttribute(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 *SecurityTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityTypeId() SBE_NOEXCEPT { - return 167; - } + 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 static SBE_CONSTEXPR std::uint64_t securityTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityTypeSinceVersion(); + return m_actingVersion >= securityTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityTypeEncodingOffset() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityTypeEncodingOffset() SBE_NOEXCEPT + { + return 59; + } - static SBE_CONSTEXPR char securityTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + 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::size_t securityTypeEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t securityTypeLength() 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 + 59; - } + SBE_NODISCARD const char *securityType() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 59; + } - SBE_NODISCARD char *securityType() SBE_NOEXCEPT { - return m_buffer + m_offset + 59; - } + SBE_NODISCARD char *securityType() SBE_NOEXCEPT + { + return m_buffer + m_offset + 59; + } - SBE_NODISCARD char securityType(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for securityType [E104]"); - } + 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 + 59 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 59 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread29 & - securityType(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for securityType [E105]"); - } + MDInstrumentDefinitionSpread29 &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 + 59 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 59 + (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::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 + 59, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 59, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionSpread29 & - putSecurityType(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 59, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionSpread29 &putSecurityType(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 59, src, sizeof(char) * 6); + return *this; + } - std::string getSecurityTypeAsString() const { - const char *buffer = m_buffer + m_offset + 59; - size_t length = 0; + SBE_NODISCARD std::string getSecurityTypeAsString() const + { + const char *buffer = m_buffer + m_offset + 59; + 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 getSecurityTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityTypeAsString(); + std::string getSecurityTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityTypeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityTypeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 59; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityTypeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 59; + 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 - MDInstrumentDefinitionSpread29 &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]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionSpread29 &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 + 59, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 59 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 59, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 59 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionSpread29 &putSecurityType(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityType [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionSpread29 &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 + 59, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 59 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 59, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 59 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - CFICodeMetaAttribute(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 *CFICodeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t cFICodeId() SBE_NOEXCEPT { return 461; } + static SBE_CONSTEXPR std::uint16_t cFICodeId() SBE_NOEXCEPT + { + return 461; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cFICodeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cFICodeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool cFICodeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool cFICodeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= cFICodeSinceVersion(); + return m_actingVersion >= cFICodeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cFICodeEncodingOffset() SBE_NOEXCEPT { - return 65; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cFICodeEncodingOffset() SBE_NOEXCEPT + { + return 65; + } - static SBE_CONSTEXPR char cFICodeNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char cFICodeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char cFICodeMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char cFICodeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char cFICodeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char cFICodeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t cFICodeEncodingLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::size_t cFICodeEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t cFICodeLength() SBE_NOEXCEPT { return 6; } + static SBE_CONSTEXPR std::uint64_t cFICodeLength() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD const char *cFICode() const SBE_NOEXCEPT { - return m_buffer + m_offset + 65; - } + SBE_NODISCARD const char *cFICode() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 65; + } - SBE_NODISCARD char *cFICode() SBE_NOEXCEPT { - return m_buffer + m_offset + 65; - } + SBE_NODISCARD char *cFICode() SBE_NOEXCEPT + { + return m_buffer + m_offset + 65; + } - SBE_NODISCARD char cFICode(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for cFICode [E104]"); - } + SBE_NODISCARD char cFICode(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for cFICode [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); + } - MDInstrumentDefinitionSpread29 & - cFICode(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for cFICode [E105]"); - } + MDInstrumentDefinitionSpread29 &cFICode(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for cFICode [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 getCFICode(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error("length too large for getCFICode [E106]"); - } + std::uint64_t getCFICode(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getCFICode [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; + } - MDInstrumentDefinitionSpread29 & - putCFICode(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 65, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionSpread29 &putCFICode(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 65, src, sizeof(char) * 6); + return *this; + } - std::string getCFICodeAsString() const { - const char *buffer = m_buffer + m_offset + 65; - size_t length = 0; + SBE_NODISCARD std::string getCFICodeAsString() const + { + const char *buffer = m_buffer + m_offset + 65; + 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 getCFICodeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCFICodeAsString(); + std::string getCFICodeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCFICodeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getCFICodeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 65; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCFICodeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 65; + 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 - MDInstrumentDefinitionSpread29 &putCFICode(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putCFICode [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionSpread29 &putCFICode(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putCFICode [E106]"); + } - std::memcpy(m_buffer + m_offset + 65, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 65 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 65, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 65 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionSpread29 &putCFICode(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putCFICode [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionSpread29 &putCFICode(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putCFICode [E106]"); + } - std::memcpy(m_buffer + m_offset + 65, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 65 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 65, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 65 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - 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 ""; - } - } + 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; - } + 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 static SBE_CONSTEXPR std::uint64_t maturityMonthYearSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool maturityMonthYearInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool maturityMonthYearInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= maturityMonthYearSinceVersion(); + return m_actingVersion >= maturityMonthYearSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maturityMonthYearEncodingOffset() SBE_NOEXCEPT { - return 71; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maturityMonthYearEncodingOffset() SBE_NOEXCEPT + { + return 71; + } - private: - MaturityMonthYear m_maturityMonthYear; +private: + MaturityMonthYear m_maturityMonthYear; - public: - SBE_NODISCARD MaturityMonthYear &maturityMonthYear() { - m_maturityMonthYear.wrap( - m_buffer, m_offset + 71, m_actingVersion, m_bufferLength); - return m_maturityMonthYear; - } +public: + SBE_NODISCARD MaturityMonthYear &maturityMonthYear() + { + m_maturityMonthYear.wrap(m_buffer, m_offset + 71, m_actingVersion, m_bufferLength); + return m_maturityMonthYear; + } - SBE_NODISCARD static const char * - CurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Currency"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Currency"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t currencyId() SBE_NOEXCEPT { return 15; } + 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 static SBE_CONSTEXPR std::uint64_t currencySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool currencyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool currencyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= currencySinceVersion(); + return m_actingVersion >= currencySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - currencyEncodingOffset() SBE_NOEXCEPT { - return 76; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t currencyEncodingOffset() SBE_NOEXCEPT + { + return 76; + } - static SBE_CONSTEXPR char currencyNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char currencyNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char currencyMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char currencyMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char currencyMaxValue() SBE_NOEXCEPT { - return (char)126; - } + 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::size_t currencyEncodingLength() SBE_NOEXCEPT + { + return 3; + } - static SBE_CONSTEXPR std::uint64_t currencyLength() 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 + 76; - } + SBE_NODISCARD const char *currency() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 76; + } - SBE_NODISCARD char *currency() SBE_NOEXCEPT { - return m_buffer + m_offset + 76; - } + SBE_NODISCARD char *currency() SBE_NOEXCEPT + { + return m_buffer + m_offset + 76; + } - SBE_NODISCARD char currency(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error("index out of range for currency [E104]"); - } + 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 + 76 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 76 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread29 & - currency(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error("index out of range for currency [E105]"); - } + MDInstrumentDefinitionSpread29 ¤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 + 76 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 76 + (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::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 + 76, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 76, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionSpread29 & - putCurrency(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 76, src, sizeof(char) * 3); - return *this; - } + MDInstrumentDefinitionSpread29 &putCurrency(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 76, src, sizeof(char) * 3); + return *this; + } - MDInstrumentDefinitionSpread29 &putCurrency( - const char value0, const char value1, const char value2) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 76, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 77, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 78, &val2, sizeof(char)); + MDInstrumentDefinitionSpread29 &putCurrency( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 76, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 77, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 78, &val2, sizeof(char)); - return *this; - } + return *this; + } - std::string getCurrencyAsString() const { - const char *buffer = m_buffer + m_offset + 76; - size_t length = 0; + SBE_NODISCARD std::string getCurrencyAsString() const + { + const char *buffer = m_buffer + m_offset + 76; + 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 getCurrencyAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCurrencyAsString(); + std::string getCurrencyAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCurrencyAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getCurrencyAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 76; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCurrencyAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 76; + 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 - MDInstrumentDefinitionSpread29 &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]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionSpread29 &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 + 76, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 76 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 76, str.data(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 76 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionSpread29 &putCurrency(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error("string too large for putCurrency [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionSpread29 &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 + 76, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 76 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 76, str.c_str(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 76 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - 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 ""; - } - } + 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; - } + 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 static SBE_CONSTEXPR std::uint64_t securitySubTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securitySubTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securitySubTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securitySubTypeSinceVersion(); + return m_actingVersion >= securitySubTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securitySubTypeEncodingOffset() SBE_NOEXCEPT { - return 79; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securitySubTypeEncodingOffset() SBE_NOEXCEPT + { + return 79; + } - static SBE_CONSTEXPR char securitySubTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securitySubTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securitySubTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securitySubTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securitySubTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char securitySubTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - securitySubTypeEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t securitySubTypeEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t securitySubTypeLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t securitySubTypeLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *securitySubType() const SBE_NOEXCEPT { - return m_buffer + m_offset + 79; - } + SBE_NODISCARD const char *securitySubType() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 79; + } - SBE_NODISCARD char *securitySubType() SBE_NOEXCEPT { - return m_buffer + m_offset + 79; - } + SBE_NODISCARD char *securitySubType() SBE_NOEXCEPT + { + return m_buffer + m_offset + 79; + } - SBE_NODISCARD char securitySubType(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error( - "index out of range for securitySubType [E104]"); - } + SBE_NODISCARD char securitySubType(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for securitySubType [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 79 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 79 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread29 & - securitySubType(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error( - "index out of range for securitySubType [E105]"); - } + MDInstrumentDefinitionSpread29 &securitySubType(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for securitySubType [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 79 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 79 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSecuritySubType(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error( - "length too large for getSecuritySubType [E106]"); - } + std::uint64_t getSecuritySubType(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getSecuritySubType [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 79, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 79, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionSpread29 & - putSecuritySubType(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 79, src, sizeof(char) * 5); - return *this; - } + MDInstrumentDefinitionSpread29 &putSecuritySubType(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 79, src, sizeof(char) * 5); + return *this; + } - std::string getSecuritySubTypeAsString() const { - const char *buffer = m_buffer + m_offset + 79; - size_t length = 0; + SBE_NODISCARD std::string getSecuritySubTypeAsString() const + { + const char *buffer = m_buffer + m_offset + 79; + 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 getSecuritySubTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecuritySubTypeAsString(); + std::string getSecuritySubTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecuritySubTypeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecuritySubTypeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 79; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecuritySubTypeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 79; + 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 - MDInstrumentDefinitionSpread29 & - putSecuritySubType(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error( - "string too large for putSecuritySubType [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionSpread29 &putSecuritySubType(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putSecuritySubType [E106]"); + } - std::memcpy(m_buffer + m_offset + 79, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 79 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 79, str.data(), srcLength); + for (size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 79 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionSpread29 &putSecuritySubType(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error( - "string too large for putSecuritySubType [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionSpread29 &putSecuritySubType(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putSecuritySubType [E106]"); + } - std::memcpy(m_buffer + m_offset + 79, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 79 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 79, str.c_str(), srcLength); + for (size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 79 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *UserDefinedInstrumentMetaAttribute( - 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 *UserDefinedInstrumentMetaAttribute(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 userDefinedInstrumentId() SBE_NOEXCEPT { - return 9779; - } + 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 static SBE_CONSTEXPR std::uint64_t userDefinedInstrumentSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool userDefinedInstrumentInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool userDefinedInstrumentInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= userDefinedInstrumentSinceVersion(); + return m_actingVersion >= userDefinedInstrumentSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - userDefinedInstrumentEncodingOffset() SBE_NOEXCEPT { - return 84; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t userDefinedInstrumentEncodingOffset() SBE_NOEXCEPT + { + return 84; + } - static SBE_CONSTEXPR char userDefinedInstrumentNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char userDefinedInstrumentNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char userDefinedInstrumentMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char userDefinedInstrumentMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char userDefinedInstrumentMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char userDefinedInstrumentMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - userDefinedInstrumentEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t userDefinedInstrumentEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD char userDefinedInstrument() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 84, sizeof(char)); - return (val); - } + SBE_NODISCARD char userDefinedInstrument() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 84, sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread29 & - userDefinedInstrument(const char value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 84, &val, sizeof(char)); - return *this; - } + MDInstrumentDefinitionSpread29 &userDefinedInstrument(const char value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 84, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char * - MatchAlgorithmMetaAttribute(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 *MatchAlgorithmMetaAttribute(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 matchAlgorithmId() SBE_NOEXCEPT { - return 1142; - } + static SBE_CONSTEXPR std::uint16_t matchAlgorithmId() SBE_NOEXCEPT + { + return 1142; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchAlgorithmSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchAlgorithmSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchAlgorithmInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchAlgorithmInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchAlgorithmSinceVersion(); + return m_actingVersion >= matchAlgorithmSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchAlgorithmEncodingOffset() SBE_NOEXCEPT { - return 85; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchAlgorithmEncodingOffset() SBE_NOEXCEPT + { + return 85; + } - static SBE_CONSTEXPR char matchAlgorithmNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char matchAlgorithmNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char matchAlgorithmMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char matchAlgorithmMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char matchAlgorithmMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char matchAlgorithmMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - matchAlgorithmEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchAlgorithmEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD char matchAlgorithm() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 85, sizeof(char)); - return (val); - } + SBE_NODISCARD char matchAlgorithm() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 85, sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread29 & - matchAlgorithm(const char value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 85, &val, sizeof(char)); - return *this; - } + MDInstrumentDefinitionSpread29 &matchAlgorithm(const char value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 85, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char * - MinTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MinTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t minTradeVolId() SBE_NOEXCEPT { - return 562; - } + static SBE_CONSTEXPR std::uint16_t minTradeVolId() SBE_NOEXCEPT + { + return 562; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minTradeVolSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minTradeVolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minTradeVolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minTradeVolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minTradeVolSinceVersion(); + return m_actingVersion >= minTradeVolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minTradeVolEncodingOffset() SBE_NOEXCEPT { - return 86; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minTradeVolEncodingOffset() SBE_NOEXCEPT + { + return 86; + } - static SBE_CONSTEXPR std::uint32_t minTradeVolNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t minTradeVolNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t minTradeVolMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t minTradeVolMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t minTradeVolMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t minTradeVolMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t minTradeVolEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t minTradeVolEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t minTradeVol() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 86, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t minTradeVol() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 86, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionSpread29 & - minTradeVol(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 86, &val, sizeof(std::uint32_t)); - return *this; - } + MDInstrumentDefinitionSpread29 &minTradeVol(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 86, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - MaxTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MaxTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t maxTradeVolId() SBE_NOEXCEPT { - return 1140; - } + static SBE_CONSTEXPR std::uint16_t maxTradeVolId() SBE_NOEXCEPT + { + return 1140; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - maxTradeVolSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maxTradeVolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool maxTradeVolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool maxTradeVolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= maxTradeVolSinceVersion(); + return m_actingVersion >= maxTradeVolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maxTradeVolEncodingOffset() SBE_NOEXCEPT { - return 90; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maxTradeVolEncodingOffset() SBE_NOEXCEPT + { + return 90; + } - static SBE_CONSTEXPR std::uint32_t maxTradeVolNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t maxTradeVolNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t maxTradeVolMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t maxTradeVolMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t maxTradeVolMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t maxTradeVolMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t maxTradeVolEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t maxTradeVolEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t maxTradeVol() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 90, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t maxTradeVol() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 90, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionSpread29 & - maxTradeVol(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 90, &val, sizeof(std::uint32_t)); - return *this; - } + MDInstrumentDefinitionSpread29 &maxTradeVol(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 90, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char *MinPriceIncrementMetaAttribute( - 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 *MinPriceIncrementMetaAttribute(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 minPriceIncrementId() SBE_NOEXCEPT { - return 969; - } + static SBE_CONSTEXPR std::uint16_t minPriceIncrementId() SBE_NOEXCEPT + { + return 969; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minPriceIncrementSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minPriceIncrementSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minPriceIncrementInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minPriceIncrementInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minPriceIncrementSinceVersion(); + return m_actingVersion >= minPriceIncrementSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minPriceIncrementEncodingOffset() SBE_NOEXCEPT { - return 94; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minPriceIncrementEncodingOffset() SBE_NOEXCEPT + { + return 94; + } - private: - PRICE m_minPriceIncrement; +private: + PRICE m_minPriceIncrement; - public: - SBE_NODISCARD PRICE &minPriceIncrement() { - m_minPriceIncrement.wrap( - m_buffer, m_offset + 94, m_actingVersion, m_bufferLength); - return m_minPriceIncrement; - } +public: + SBE_NODISCARD PRICE &minPriceIncrement() + { + m_minPriceIncrement.wrap(m_buffer, m_offset + 94, m_actingVersion, m_bufferLength); + return m_minPriceIncrement; + } - SBE_NODISCARD static const char * - DisplayFactorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "float"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DisplayFactorMetaAttribute(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 displayFactorId() SBE_NOEXCEPT { - return 9787; - } + static SBE_CONSTEXPR std::uint16_t displayFactorId() SBE_NOEXCEPT + { + return 9787; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - displayFactorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t displayFactorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool displayFactorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool displayFactorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= displayFactorSinceVersion(); + return m_actingVersion >= displayFactorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - displayFactorEncodingOffset() SBE_NOEXCEPT { - return 102; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t displayFactorEncodingOffset() SBE_NOEXCEPT + { + return 102; + } - private: - FLOAT m_displayFactor; +private: + FLOAT m_displayFactor; - public: - SBE_NODISCARD FLOAT &displayFactor() { - m_displayFactor.wrap( - m_buffer, m_offset + 102, m_actingVersion, m_bufferLength); - return m_displayFactor; - } +public: + SBE_NODISCARD FLOAT &displayFactor() + { + m_displayFactor.wrap(m_buffer, m_offset + 102, m_actingVersion, m_bufferLength); + return m_displayFactor; + } - SBE_NODISCARD static const char *PriceDisplayFormatMetaAttribute( - 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 *PriceDisplayFormatMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t priceDisplayFormatId() SBE_NOEXCEPT { - return 9800; - } + static SBE_CONSTEXPR std::uint16_t priceDisplayFormatId() SBE_NOEXCEPT + { + return 9800; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceDisplayFormatSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceDisplayFormatSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool priceDisplayFormatInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool priceDisplayFormatInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= priceDisplayFormatSinceVersion(); + return m_actingVersion >= priceDisplayFormatSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceDisplayFormatEncodingOffset() SBE_NOEXCEPT { - return 110; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceDisplayFormatEncodingOffset() SBE_NOEXCEPT + { + return 110; + } - static SBE_CONSTEXPR std::uint8_t - priceDisplayFormatNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t priceDisplayFormatNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - priceDisplayFormatEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t priceDisplayFormatEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t priceDisplayFormat() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 110, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t priceDisplayFormat() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 110, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionSpread29 & - priceDisplayFormat(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 110, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionSpread29 &priceDisplayFormat(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 110, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - PriceRatioMetaAttribute(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 *PriceRatioMetaAttribute(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 priceRatioId() SBE_NOEXCEPT { - return 5770; - } + static SBE_CONSTEXPR std::uint16_t priceRatioId() SBE_NOEXCEPT + { + return 5770; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceRatioSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceRatioSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool priceRatioInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool priceRatioInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= priceRatioSinceVersion(); + return m_actingVersion >= priceRatioSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceRatioEncodingOffset() SBE_NOEXCEPT { - return 111; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceRatioEncodingOffset() SBE_NOEXCEPT + { + return 111; + } - private: - PRICENULL m_priceRatio; +private: + PRICENULL m_priceRatio; - public: - SBE_NODISCARD PRICENULL &priceRatio() { - m_priceRatio.wrap( - m_buffer, m_offset + 111, m_actingVersion, m_bufferLength); - return m_priceRatio; - } +public: + SBE_NODISCARD PRICENULL &priceRatio() + { + m_priceRatio.wrap(m_buffer, m_offset + 111, m_actingVersion, m_bufferLength); + return m_priceRatio; + } - SBE_NODISCARD static const char * - TickRuleMetaAttribute(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 *TickRuleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t tickRuleId() SBE_NOEXCEPT { return 6350; } + static SBE_CONSTEXPR std::uint16_t tickRuleId() SBE_NOEXCEPT + { + return 6350; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tickRuleSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tickRuleSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool tickRuleInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tickRuleInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tickRuleSinceVersion(); + return m_actingVersion >= tickRuleSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tickRuleEncodingOffset() SBE_NOEXCEPT { - return 119; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tickRuleEncodingOffset() SBE_NOEXCEPT + { + return 119; + } - static SBE_CONSTEXPR std::int8_t tickRuleNullValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t tickRuleNullValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::int8_t tickRuleMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } + static SBE_CONSTEXPR std::int8_t tickRuleMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } - static SBE_CONSTEXPR std::int8_t tickRuleMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t tickRuleMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::size_t tickRuleEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t tickRuleEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::int8_t tickRule() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 119, sizeof(std::int8_t)); - return (val); - } + SBE_NODISCARD std::int8_t tickRule() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 119, sizeof(std::int8_t)); + return (val); + } - MDInstrumentDefinitionSpread29 & - tickRule(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 119, &val, sizeof(std::int8_t)); - return *this; - } + MDInstrumentDefinitionSpread29 &tickRule(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 119, &val, sizeof(std::int8_t)); + return *this; + } - SBE_NODISCARD static const char * - UnitOfMeasureMetaAttribute(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 *UnitOfMeasureMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t unitOfMeasureId() SBE_NOEXCEPT { - return 996; - } + static SBE_CONSTEXPR std::uint16_t unitOfMeasureId() SBE_NOEXCEPT + { + return 996; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - unitOfMeasureSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t unitOfMeasureSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool unitOfMeasureInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool unitOfMeasureInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= unitOfMeasureSinceVersion(); + return m_actingVersion >= unitOfMeasureSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - unitOfMeasureEncodingOffset() SBE_NOEXCEPT { - return 120; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t unitOfMeasureEncodingOffset() SBE_NOEXCEPT + { + return 120; + } - static SBE_CONSTEXPR char unitOfMeasureNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char unitOfMeasureNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char unitOfMeasureMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char unitOfMeasureMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char unitOfMeasureMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char unitOfMeasureMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t unitOfMeasureEncodingLength() SBE_NOEXCEPT { - return 30; - } + static SBE_CONSTEXPR std::size_t unitOfMeasureEncodingLength() SBE_NOEXCEPT + { + return 30; + } - static SBE_CONSTEXPR std::uint64_t unitOfMeasureLength() SBE_NOEXCEPT { - return 30; - } + static SBE_CONSTEXPR std::uint64_t unitOfMeasureLength() SBE_NOEXCEPT + { + return 30; + } - SBE_NODISCARD const char *unitOfMeasure() const SBE_NOEXCEPT { - return m_buffer + m_offset + 120; - } + SBE_NODISCARD const char *unitOfMeasure() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 120; + } - SBE_NODISCARD char *unitOfMeasure() SBE_NOEXCEPT { - return m_buffer + m_offset + 120; - } + SBE_NODISCARD char *unitOfMeasure() SBE_NOEXCEPT + { + return m_buffer + m_offset + 120; + } - SBE_NODISCARD char unitOfMeasure(const std::uint64_t index) const { - if (index >= 30) { - throw std::runtime_error( - "index out of range for unitOfMeasure [E104]"); - } + SBE_NODISCARD char unitOfMeasure(const std::uint64_t index) const + { + if (index >= 30) + { + throw std::runtime_error("index out of range for unitOfMeasure [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 120 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 120 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread29 & - unitOfMeasure(const std::uint64_t index, const char value) { - if (index >= 30) { - throw std::runtime_error( - "index out of range for unitOfMeasure [E105]"); - } + MDInstrumentDefinitionSpread29 &unitOfMeasure(const std::uint64_t index, const char value) + { + if (index >= 30) + { + throw std::runtime_error("index out of range for unitOfMeasure [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 120 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 120 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getUnitOfMeasure(char *const dst, const std::uint64_t length) const { - if (length > 30) { - throw std::runtime_error( - "length too large for getUnitOfMeasure [E106]"); - } + std::uint64_t getUnitOfMeasure(char *const dst, const std::uint64_t length) const + { + if (length > 30) + { + throw std::runtime_error("length too large for getUnitOfMeasure [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 120, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 120, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionSpread29 & - putUnitOfMeasure(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 120, src, sizeof(char) * 30); - return *this; - } + MDInstrumentDefinitionSpread29 &putUnitOfMeasure(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 120, src, sizeof(char) * 30); + return *this; + } - std::string getUnitOfMeasureAsString() const { - const char *buffer = m_buffer + m_offset + 120; - size_t length = 0; + SBE_NODISCARD std::string getUnitOfMeasureAsString() const + { + const char *buffer = m_buffer + m_offset + 120; + 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 getUnitOfMeasureAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getUnitOfMeasureAsString(); + std::string getUnitOfMeasureAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getUnitOfMeasureAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getUnitOfMeasureAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 120; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getUnitOfMeasureAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 120; + 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 - MDInstrumentDefinitionSpread29 & - putUnitOfMeasure(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 30) { - throw std::runtime_error( - "string too large for putUnitOfMeasure [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionSpread29 &putUnitOfMeasure(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 30) + { + throw std::runtime_error("string too large for putUnitOfMeasure [E106]"); + } - std::memcpy(m_buffer + m_offset + 120, str.data(), srcLength); - for (size_t start = srcLength; start < 30; ++start) { - m_buffer[m_offset + 120 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 120, str.data(), srcLength); + for (size_t start = srcLength; start < 30; ++start) + { + m_buffer[m_offset + 120 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionSpread29 &putUnitOfMeasure(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 30) { - throw std::runtime_error( - "string too large for putUnitOfMeasure [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionSpread29 &putUnitOfMeasure(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 30) + { + throw std::runtime_error("string too large for putUnitOfMeasure [E106]"); + } - std::memcpy(m_buffer + m_offset + 120, str.c_str(), srcLength); - for (size_t start = srcLength; start < 30; ++start) { - m_buffer[m_offset + 120 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 120, str.c_str(), srcLength); + for (size_t start = srcLength; start < 30; ++start) + { + m_buffer[m_offset + 120 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *TradingReferencePriceMetaAttribute( - 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 *TradingReferencePriceMetaAttribute(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 tradingReferencePriceId() SBE_NOEXCEPT { - return 1150; - } + static SBE_CONSTEXPR std::uint16_t tradingReferencePriceId() SBE_NOEXCEPT + { + return 1150; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingReferencePriceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingReferencePriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool tradingReferencePriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tradingReferencePriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tradingReferencePriceSinceVersion(); + return m_actingVersion >= tradingReferencePriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingReferencePriceEncodingOffset() SBE_NOEXCEPT { - return 150; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingReferencePriceEncodingOffset() SBE_NOEXCEPT + { + return 150; + } - private: - PRICENULL m_tradingReferencePrice; +private: + PRICENULL m_tradingReferencePrice; - public: - SBE_NODISCARD PRICENULL &tradingReferencePrice() { - m_tradingReferencePrice.wrap( - m_buffer, m_offset + 150, m_actingVersion, m_bufferLength); - return m_tradingReferencePrice; - } +public: + SBE_NODISCARD PRICENULL &tradingReferencePrice() + { + m_tradingReferencePrice.wrap(m_buffer, m_offset + 150, m_actingVersion, m_bufferLength); + return m_tradingReferencePrice; + } - SBE_NODISCARD static const char * - SettlPriceTypeMetaAttribute(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 *SettlPriceTypeMetaAttribute(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 settlPriceTypeId() SBE_NOEXCEPT { - return 731; - } + static SBE_CONSTEXPR std::uint16_t settlPriceTypeId() SBE_NOEXCEPT + { + return 731; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - settlPriceTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t settlPriceTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= settlPriceTypeSinceVersion(); + return m_actingVersion >= settlPriceTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingOffset() SBE_NOEXCEPT { - return 158; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingOffset() SBE_NOEXCEPT + { + return 158; + } - private: - SettlPriceType m_settlPriceType; +private: + SettlPriceType m_settlPriceType; - public: - SBE_NODISCARD SettlPriceType &settlPriceType() { - m_settlPriceType.wrap( - m_buffer, m_offset + 158, m_actingVersion, m_bufferLength); - return m_settlPriceType; - } +public: + SBE_NODISCARD SettlPriceType &settlPriceType() + { + m_settlPriceType.wrap(m_buffer, m_offset + 158, m_actingVersion, m_bufferLength); + return m_settlPriceType; + } - static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char *OpenInterestQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OpenInterestQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t openInterestQtyId() SBE_NOEXCEPT { - return 5792; - } + static SBE_CONSTEXPR std::uint16_t openInterestQtyId() SBE_NOEXCEPT + { + return 5792; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - openInterestQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t openInterestQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool openInterestQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool openInterestQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= openInterestQtySinceVersion(); + return m_actingVersion >= openInterestQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - openInterestQtyEncodingOffset() SBE_NOEXCEPT { - return 159; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t openInterestQtyEncodingOffset() SBE_NOEXCEPT + { + return 159; + } - static SBE_CONSTEXPR std::int32_t openInterestQtyNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t openInterestQtyNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t openInterestQtyMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t openInterestQtyMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t openInterestQtyMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t openInterestQtyMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t - openInterestQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t openInterestQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t openInterestQty() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 159, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t openInterestQty() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 159, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionSpread29 & - openInterestQty(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 159, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionSpread29 &openInterestQty(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 159, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - ClearedVolumeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ClearedVolumeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t clearedVolumeId() SBE_NOEXCEPT { - return 5791; - } + static SBE_CONSTEXPR std::uint16_t clearedVolumeId() SBE_NOEXCEPT + { + return 5791; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clearedVolumeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clearedVolumeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool clearedVolumeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool clearedVolumeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clearedVolumeSinceVersion(); + return m_actingVersion >= clearedVolumeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clearedVolumeEncodingOffset() SBE_NOEXCEPT { - return 163; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clearedVolumeEncodingOffset() SBE_NOEXCEPT + { + return 163; + } - static SBE_CONSTEXPR std::int32_t clearedVolumeNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t clearedVolumeNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t clearedVolumeMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t clearedVolumeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t clearedVolumeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t clearedVolumeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t clearedVolumeEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t clearedVolumeEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t clearedVolume() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 163, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t clearedVolume() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 163, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionSpread29 & - clearedVolume(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 163, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionSpread29 &clearedVolume(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 163, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - HighLimitPriceMetaAttribute(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 *HighLimitPriceMetaAttribute(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 highLimitPriceId() SBE_NOEXCEPT { - return 1149; - } + static SBE_CONSTEXPR std::uint16_t highLimitPriceId() SBE_NOEXCEPT + { + return 1149; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - highLimitPriceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t highLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= highLimitPriceSinceVersion(); + return m_actingVersion >= highLimitPriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - highLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 167; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t highLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 167; + } - private: - PRICENULL m_highLimitPrice; +private: + PRICENULL m_highLimitPrice; - public: - SBE_NODISCARD PRICENULL &highLimitPrice() { - m_highLimitPrice.wrap( - m_buffer, m_offset + 167, m_actingVersion, m_bufferLength); - return m_highLimitPrice; - } +public: + SBE_NODISCARD PRICENULL &highLimitPrice() + { + m_highLimitPrice.wrap(m_buffer, m_offset + 167, m_actingVersion, m_bufferLength); + return m_highLimitPrice; + } - SBE_NODISCARD static const char * - LowLimitPriceMetaAttribute(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 *LowLimitPriceMetaAttribute(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 lowLimitPriceId() SBE_NOEXCEPT { - return 1148; - } + static SBE_CONSTEXPR std::uint16_t lowLimitPriceId() SBE_NOEXCEPT + { + return 1148; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lowLimitPriceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lowLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lowLimitPriceSinceVersion(); + return m_actingVersion >= lowLimitPriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lowLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 175; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lowLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 175; + } - private: - PRICENULL m_lowLimitPrice; +private: + PRICENULL m_lowLimitPrice; - public: - SBE_NODISCARD PRICENULL &lowLimitPrice() { - m_lowLimitPrice.wrap( - m_buffer, m_offset + 175, m_actingVersion, m_bufferLength); - return m_lowLimitPrice; - } +public: + SBE_NODISCARD PRICENULL &lowLimitPrice() + { + m_lowLimitPrice.wrap(m_buffer, m_offset + 175, m_actingVersion, m_bufferLength); + return m_lowLimitPrice; + } - SBE_NODISCARD static const char *MaxPriceVariationMetaAttribute( - 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 *MaxPriceVariationMetaAttribute(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 maxPriceVariationId() SBE_NOEXCEPT { - return 1143; - } + static SBE_CONSTEXPR std::uint16_t maxPriceVariationId() SBE_NOEXCEPT + { + return 1143; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - maxPriceVariationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maxPriceVariationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool maxPriceVariationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool maxPriceVariationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= maxPriceVariationSinceVersion(); + return m_actingVersion >= maxPriceVariationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maxPriceVariationEncodingOffset() SBE_NOEXCEPT { - return 183; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maxPriceVariationEncodingOffset() SBE_NOEXCEPT + { + return 183; + } - private: - PRICENULL m_maxPriceVariation; +private: + PRICENULL m_maxPriceVariation; - public: - SBE_NODISCARD PRICENULL &maxPriceVariation() { - m_maxPriceVariation.wrap( - m_buffer, m_offset + 183, m_actingVersion, m_bufferLength); - return m_maxPriceVariation; - } +public: + SBE_NODISCARD PRICENULL &maxPriceVariation() + { + m_maxPriceVariation.wrap(m_buffer, m_offset + 183, m_actingVersion, m_bufferLength); + return m_maxPriceVariation; + } - SBE_NODISCARD static const char * - MainFractionMetaAttribute(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 *MainFractionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mainFractionId() SBE_NOEXCEPT { - return 37702; - } + static SBE_CONSTEXPR std::uint16_t mainFractionId() SBE_NOEXCEPT + { + return 37702; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mainFractionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mainFractionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mainFractionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mainFractionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mainFractionSinceVersion(); + return m_actingVersion >= mainFractionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mainFractionEncodingOffset() SBE_NOEXCEPT { - return 191; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mainFractionEncodingOffset() SBE_NOEXCEPT + { + return 191; + } - static SBE_CONSTEXPR std::uint8_t mainFractionNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t mainFractionNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t mainFractionMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t mainFractionMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t mainFractionMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t mainFractionMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t mainFractionEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t mainFractionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t mainFraction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 191, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t mainFraction() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 191, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionSpread29 & - mainFraction(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 191, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionSpread29 &mainFraction(const std::uint8_t 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 * - SubFractionMetaAttribute(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 *SubFractionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t subFractionId() SBE_NOEXCEPT { - return 37703; - } + static SBE_CONSTEXPR std::uint16_t subFractionId() SBE_NOEXCEPT + { + return 37703; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - subFractionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t subFractionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool subFractionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool subFractionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= subFractionSinceVersion(); + return m_actingVersion >= subFractionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - subFractionEncodingOffset() SBE_NOEXCEPT { - return 192; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t subFractionEncodingOffset() SBE_NOEXCEPT + { + return 192; + } - static SBE_CONSTEXPR std::uint8_t subFractionNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t subFractionNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t subFractionMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t subFractionMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t subFractionMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t subFractionMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t subFractionEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t subFractionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t subFraction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 192, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t subFraction() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 192, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionSpread29 & - subFraction(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 192, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionSpread29 &subFraction(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 192, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char *TradingReferenceDateMetaAttribute( - 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 *TradingReferenceDateMetaAttribute(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 tradingReferenceDateId() SBE_NOEXCEPT { - return 5796; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateId() SBE_NOEXCEPT + { + return 5796; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingReferenceDateSinceVersion() SBE_NOEXCEPT { - return 6; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingReferenceDateSinceVersion() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tradingReferenceDateSinceVersion(); + return m_actingVersion >= tradingReferenceDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingOffset() SBE_NOEXCEPT { - return 193; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingOffset() SBE_NOEXCEPT + { + return 193; + } - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t tradingReferenceDate() const SBE_NOEXCEPT { - if (m_actingVersion < 6) { - return (std::uint16_t)65535; - } + SBE_NODISCARD std::uint16_t tradingReferenceDate() const SBE_NOEXCEPT + { + if (m_actingVersion < 6) + { + return static_cast(65535); + } - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 193, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 193, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - MDInstrumentDefinitionSpread29 & - tradingReferenceDate(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; - } + MDInstrumentDefinitionSpread29 &tradingReferenceDate(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; + } - class NoEvents { + class NoEvents + { 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 NoEvents &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(static_cast(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 *EventTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t eventTypeId() SBE_NOEXCEPT + { + return 865; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t eventTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool eventTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= eventTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t eventTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t eventTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD EventType::Value eventType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint8_t)); + return EventType::get((val)); + } + + NoEvents &eventType(const EventType::Value 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 *EventTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t eventTimeId() SBE_NOEXCEPT + { + return 1145; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t eventTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool eventTimeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= eventTimeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t eventTimeEncodingOffset() SBE_NOEXCEPT + { + return 1; + } + + static SBE_CONSTEXPR std::uint64_t eventTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t eventTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t eventTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t eventTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t eventTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoEvents &eventTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint64_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoEvents writer) + { + builder << '{'; + builder << R"("EventType": )"; + builder << '"' << writer.eventType() << '"'; + + builder << ", "; + builder << R"("EventTime": )"; + builder << +writer.eventTime(); + + 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: + NoEvents m_noEvents; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 9; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoEventsId() SBE_NOEXCEPT + { + return 864; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoEvents &noEvents() + { + m_noEvents.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noEvents; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoEvents &noEventsCount(const std::uint8_t count) + { + m_noEvents.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noEvents; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noEventsSinceVersion() 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 NoEvents &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 * - EventTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t eventTypeId() SBE_NOEXCEPT { - return 865; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - eventTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool eventTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noEventsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= eventTypeSinceVersion(); + return m_actingVersion >= noEventsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - eventTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - eventTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD EventType::Value eventType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint8_t)); - return EventType::get((val)); - } - - NoEvents &eventType(const EventType::Value 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 * - EventTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t eventTimeId() SBE_NOEXCEPT { - return 1145; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - eventTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool eventTimeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= eventTimeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - eventTimeEncodingOffset() SBE_NOEXCEPT { - return 1; - } - - static SBE_CONSTEXPR std::uint64_t eventTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t eventTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t eventTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t eventTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t eventTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoEvents &eventTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint64_t)); - return *this; - } - - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoEvents writer) { - builder << '{'; - builder << R"("EventType": )"; - builder << '"' << writer.eventType() << '"'; - - builder << ", "; - builder << R"("EventTime": )"; - builder << +writer.eventTime(); - - builder << '}'; - - return builder; - } - }; - - private: - NoEvents m_noEvents; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoEventsId() SBE_NOEXCEPT { - return 864; - } - - SBE_NODISCARD inline NoEvents &noEvents() { - m_noEvents.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noEvents; - } - - NoEvents &noEventsCount(const std::uint8_t count) { - m_noEvents.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noEvents; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noEventsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noEventsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noEventsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoMDFeedTypes { + class NoMDFeedTypes + { 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)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 { 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 < m_count; - } - - inline NoMDFeedTypes &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 * - MDFeedTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDFeedTypeId() SBE_NOEXCEPT { - return 1022; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDFeedTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDFeedTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDFeedTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDFeedTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR char mDFeedTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char mDFeedTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char mDFeedTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t mDFeedTypeEncodingLength() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t mDFeedTypeLength() SBE_NOEXCEPT { - return 3; - } - - SBE_NODISCARD const char *mDFeedType() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char *mDFeedType() SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char mDFeedType(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error( - "index out of range for mDFeedType [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } - - NoMDFeedTypes &mDFeedType(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error( - "index out of range for mDFeedType [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getMDFeedType(char *const dst, const std::uint64_t length) const { - if (length > 3) { - throw std::runtime_error( - "length too large for getMDFeedType [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } - - NoMDFeedTypes &putMDFeedType(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 3); - return *this; - } - - NoMDFeedTypes & - putMDFeedType(const char value0, const char value1, const char value2) - SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 0, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 1, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 2, &val2, sizeof(char)); - - return *this; - } - - std::string getMDFeedTypeAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 3 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getMDFeedTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getMDFeedTypeAsString(); - - 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; - } + 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 - std::string_view getMDFeedTypeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 3 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - NoMDFeedTypes &putMDFeedType(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putMDFeedType [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#else - NoMDFeedTypes &putMDFeedType(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putMDFeedType [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - MarketDepthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t marketDepthId() SBE_NOEXCEPT { - return 264; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - marketDepthSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool marketDepthInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= marketDepthSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - marketDepthEncodingOffset() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::int8_t marketDepthNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t marketDepthMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t marketDepthMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t - marketDepthEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::int8_t marketDepth() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 3, sizeof(std::int8_t)); - return (val); - } - - NoMDFeedTypes &marketDepth(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 3, &val, sizeof(std::int8_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDFeedTypes writer) { - builder << '{'; - builder << R"("MDFeedType": )"; - builder << '"' << writer.getMDFeedTypeAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("MarketDepth": )"; - builder << +writer.marketDepth(); - - builder << '}'; - - return builder; - } - }; - - private: - NoMDFeedTypes m_noMDFeedTypes; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDFeedTypesId() SBE_NOEXCEPT { - return 1141; - } - - SBE_NODISCARD inline NoMDFeedTypes &noMDFeedTypes() { - m_noMDFeedTypes.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDFeedTypes; - } - - NoMDFeedTypes &noMDFeedTypesCount(const std::uint8_t count) { - m_noMDFeedTypes.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDFeedTypes; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDFeedTypesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDFeedTypesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDFeedTypesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoInstAttrib { - 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)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 { 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 < m_count; - } - - inline NoInstAttrib &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 *InstAttribTypeMetaAttribute( - 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 instAttribTypeId() SBE_NOEXCEPT { - return 871; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - instAttribTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool instAttribTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= instAttribTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - instAttribTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int8_t instAttribTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t instAttribTypeMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t instAttribTypeMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t - instAttribTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::int8_t - instAttribType() SBE_NOEXCEPT { - return (std::int8_t)24; - } - - SBE_NODISCARD static const char *InstAttribValueMetaAttribute( - 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 instAttribValueId() SBE_NOEXCEPT { - return 872; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - instAttribValueSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool instAttribValueInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= instAttribValueSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - instAttribValueEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - private: - InstAttribValue m_instAttribValue; - - public: - SBE_NODISCARD InstAttribValue &instAttribValue() { - m_instAttribValue.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_instAttribValue; - } - - static SBE_CONSTEXPR std::size_t - instAttribValueEncodingLength() SBE_NOEXCEPT { - return 4; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoInstAttrib writer) { - builder << '{'; - builder << R"("InstAttribValue": )"; - builder << writer.instAttribValue(); - - builder << '}'; - - return builder; - } - }; - - private: - NoInstAttrib m_noInstAttrib; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoInstAttribId() SBE_NOEXCEPT { - return 870; - } - - SBE_NODISCARD inline NoInstAttrib &noInstAttrib() { - m_noInstAttrib.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noInstAttrib; - } - - NoInstAttrib &noInstAttribCount(const std::uint8_t count) { - m_noInstAttrib.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noInstAttrib; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noInstAttribSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noInstAttribInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noInstAttribSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoLotTypeRules { - 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)5); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 5; - 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 5; - } - - 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 < m_count; - } - - inline NoLotTypeRules &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 * - LotTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t lotTypeId() SBE_NOEXCEPT { - return 1093; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lotTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lotTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= lotTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lotTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int8_t lotTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t lotTypeMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t lotTypeMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t lotTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::int8_t lotType() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int8_t)); - return (val); - } - - NoLotTypeRules &lotType(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int8_t)); - return *this; - } - - SBE_NODISCARD static const char * - MinLotSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t minLotSizeId() SBE_NOEXCEPT { - return 1231; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minLotSizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool minLotSizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= minLotSizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minLotSizeEncodingOffset() SBE_NOEXCEPT { - return 1; - } - - private: - DecimalQty m_minLotSize; - - public: - SBE_NODISCARD DecimalQty &minLotSize() { - m_minLotSize.wrap( - m_buffer, m_offset + 1, m_actingVersion, m_bufferLength); - return m_minLotSize; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoLotTypeRules writer) { - builder << '{'; - builder << R"("LotType": )"; - builder << +writer.lotType(); - - builder << ", "; - builder << R"("MinLotSize": )"; - builder << writer.minLotSize(); - - builder << '}'; - - return builder; - } - }; - - private: - NoLotTypeRules m_noLotTypeRules; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoLotTypeRulesId() SBE_NOEXCEPT { - return 1234; - } - - SBE_NODISCARD inline NoLotTypeRules &noLotTypeRules() { - m_noLotTypeRules.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLotTypeRules; - } - - NoLotTypeRules &noLotTypeRulesCount(const std::uint8_t count) { - m_noLotTypeRules.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLotTypeRules; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noLotTypeRulesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noLotTypeRulesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noLotTypeRulesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - 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)18); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 18; - 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 18; - } - - 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 < 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 *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 0; - } - - 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 + 0, 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 + 0, &val, sizeof(std::int32_t)); - return *this; - } - - 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 4; - } - - static SBE_CONSTEXPR char legSecurityIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char legSecurityIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char legSecurityIDSourceMaxValue() SBE_NOEXCEPT { - return (char)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}; - - return (const char *)legSecurityIDSourceValues; - } - - SBE_NODISCARD char legSecurityIDSource(const std::uint64_t index) const { - static const std::uint8_t legSecurityIDSourceValues[] = {56}; - - 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 (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; - } + #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; + } + + 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; + } - return oss.str(); - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - 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 inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - static SBE_CONSTEXPR std::uint16_t legSideId() SBE_NOEXCEPT { - return 624; - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legSideSinceVersion() SBE_NOEXCEPT { - return 0; - } + inline NoMDFeedTypes &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 bool legSideInActingVersion() SBE_NOEXCEPT { + 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(static_cast(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 *MDFeedTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDFeedTypeId() SBE_NOEXCEPT + { + return 1022; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDFeedTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDFeedTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDFeedTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDFeedTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR char mDFeedTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char mDFeedTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char mDFeedTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t mDFeedTypeEncodingLength() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t mDFeedTypeLength() SBE_NOEXCEPT + { + return 3; + } + + SBE_NODISCARD const char *mDFeedType() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } + + SBE_NODISCARD char *mDFeedType() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } + + SBE_NODISCARD char mDFeedType(const std::uint64_t index) const + { + if (index >= 3) + { + throw std::runtime_error("index out of range for mDFeedType [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } + + NoMDFeedTypes &mDFeedType(const std::uint64_t index, const char value) + { + if (index >= 3) + { + throw std::runtime_error("index out of range for mDFeedType [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getMDFeedType(char *const dst, const std::uint64_t length) const + { + if (length > 3) + { + throw std::runtime_error("length too large for getMDFeedType [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } + + NoMDFeedTypes &putMDFeedType(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 3); + return *this; + } + + NoMDFeedTypes &putMDFeedType( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 0, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 1, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 2, &val2, sizeof(char)); + + return *this; + } + + SBE_NODISCARD std::string getMDFeedTypeAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + size_t length = 0; + + for (; length < 3 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getMDFeedTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getMDFeedTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + 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 getMDFeedTypeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + size_t length = 0; + + for (; length < 3 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoMDFeedTypes &putMDFeedType(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putMDFeedType [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #else + NoMDFeedTypes &putMDFeedType(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putMDFeedType [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *MarketDepthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t marketDepthId() SBE_NOEXCEPT + { + return 264; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t marketDepthSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool marketDepthInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= marketDepthSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t marketDepthEncodingOffset() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::int8_t marketDepthNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t marketDepthMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t marketDepthMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t marketDepthEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::int8_t marketDepth() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 3, sizeof(std::int8_t)); + return (val); + } + + NoMDFeedTypes &marketDepth(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 3, &val, sizeof(std::int8_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDFeedTypes writer) + { + builder << '{'; + builder << R"("MDFeedType": )"; + builder << '"' << + writer.getMDFeedTypeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("MarketDepth": )"; + builder << +writer.marketDepth(); + + 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: + NoMDFeedTypes m_noMDFeedTypes; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDFeedTypesId() SBE_NOEXCEPT + { + return 1141; + } + + SBE_NODISCARD inline NoMDFeedTypes &noMDFeedTypes() + { + m_noMDFeedTypes.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDFeedTypes; + } + + NoMDFeedTypes &noMDFeedTypesCount(const std::uint8_t count) + { + m_noMDFeedTypes.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDFeedTypes; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDFeedTypesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noMDFeedTypesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= legSideSinceVersion(); + return m_actingVersion >= noMDFeedTypesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legSideEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legSideEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD LegSide::Value legSide() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint8_t)); - return LegSide::get((val)); - } - - NoLegs &legSide(const LegSide::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 4, &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 "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - 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 5; - } - - static SBE_CONSTEXPR std::int8_t legRatioQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t legRatioQtyMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t legRatioQtyMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t - legRatioQtyEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::int8_t legRatioQty() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 5, sizeof(std::int8_t)); - return (val); - } - - NoLegs &legRatioQty(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 5, &val, sizeof(std::int8_t)); - return *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 6; - } + } + class NoInstAttrib + { private: - PRICENULL 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 PRICENULL &legPrice() { - m_legPrice.wrap( - m_buffer, m_offset + 6, 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 *LegOptionDeltaMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - 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(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; + } - static SBE_CONSTEXPR std::uint16_t legOptionDeltaId() SBE_NOEXCEPT { - return 1017; - } + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legOptionDeltaSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 4; + } - 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 std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legOptionDeltaEncodingOffset() SBE_NOEXCEPT { - return 14; - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 NoInstAttrib &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(static_cast(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 *InstAttribTypeMetaAttribute(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 instAttribTypeId() SBE_NOEXCEPT + { + return 871; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t instAttribTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool instAttribTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= instAttribTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t instAttribTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::int8_t instAttribTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t instAttribTypeMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t instAttribTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t instAttribTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::int8_t instAttribType() SBE_NOEXCEPT + { + return static_cast(24); + } + + SBE_NODISCARD static const char *InstAttribValueMetaAttribute(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 instAttribValueId() SBE_NOEXCEPT + { + return 872; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t instAttribValueSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool instAttribValueInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= instAttribValueSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t instAttribValueEncodingOffset() SBE_NOEXCEPT + { + return 0; + } private: - DecimalQty m_legOptionDelta; + InstAttribValue m_instAttribValue; public: - SBE_NODISCARD DecimalQty &legOptionDelta() { - m_legOptionDelta.wrap( - m_buffer, m_offset + 14, m_actingVersion, m_bufferLength); - return m_legOptionDelta; - } + SBE_NODISCARD InstAttribValue &instAttribValue() + { + m_instAttribValue.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_instAttribValue; + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoLegs writer) { - builder << '{'; - builder << R"("LegSecurityID": )"; - builder << +writer.legSecurityID(); + static SBE_CONSTEXPR std::size_t instAttribValueEncodingLength() SBE_NOEXCEPT + { + return 4; + } - builder << ", "; - builder << R"("LegSide": )"; - builder << '"' << writer.legSide() << '"'; + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoInstAttrib writer) + { + builder << '{'; + builder << R"("InstAttribValue": )"; + builder << writer.instAttribValue(); - builder << ", "; - builder << R"("LegRatioQty": )"; - builder << +writer.legRatioQty(); + builder << '}'; - builder << ", "; - builder << R"("LegPrice": )"; - builder << writer.legPrice(); + return builder; + } - builder << ", "; - builder << R"("LegOptionDelta": )"; - builder << writer.legOptionDelta(); + void skip() + { + } - builder << '}'; + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } - return builder; - } - }; + 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(); - private: - NoLegs m_noLegs; + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif + } + }; - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoLegsId() SBE_NOEXCEPT { - return 555; - } +private: + NoInstAttrib m_noInstAttrib; - SBE_NODISCARD inline NoLegs &noLegs() { - m_noLegs.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLegs; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoInstAttribId() SBE_NOEXCEPT + { + return 870; + } - NoLegs &noLegsCount(const std::uint8_t count) { - m_noLegs.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLegs; - } + SBE_NODISCARD inline NoInstAttrib &noInstAttrib() + { + m_noInstAttrib.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noInstAttrib; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noLegsSinceVersion() SBE_NOEXCEPT { - return 0; - } + NoInstAttrib &noInstAttribCount(const std::uint8_t count) + { + m_noInstAttrib.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noInstAttrib; + } - SBE_NODISCARD bool noLegsInActingVersion() const SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noInstAttribSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noInstAttribInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noLegsSinceVersion(); + return m_actingVersion >= noInstAttribSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDInstrumentDefinitionSpread29 _writer) { - MDInstrumentDefinitionSpread29 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDInstrumentDefinitionSpread29", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + class NoLotTypeRules + { + 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"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } - builder << ", "; - builder << R"("TotNumReports": )"; - builder << +writer.totNumReports(); + 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"("SecurityUpdateAction": )"; - builder << '"' << writer.securityUpdateAction() << '"'; + 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(5)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 5; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - builder << ", "; - builder << R"("LastUpdateTime": )"; - builder << +writer.lastUpdateTime(); + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } - builder << ", "; - builder << R"("MDSecurityTradingStatus": )"; - builder << '"' << writer.mDSecurityTradingStatus() << '"'; + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 5; + } - builder << ", "; - builder << R"("ApplID": )"; - builder << +writer.applID(); + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - builder << ", "; - builder << R"("MarketSegmentID": )"; - builder << +writer.marketSegmentID(); + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - builder << ", "; - builder << R"("UnderlyingProduct": )"; - builder << +writer.underlyingProduct(); + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - builder << ", "; - builder << R"("SecurityExchange": )"; - builder << '"' << writer.getSecurityExchangeAsJsonEscapedString().c_str() - << '"'; + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - builder << ", "; - builder << R"("SecurityGroup": )"; - builder << '"' << writer.getSecurityGroupAsJsonEscapedString().c_str() - << '"'; + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - builder << ", "; - builder << R"("Asset": )"; - builder << '"' << writer.getAssetAsJsonEscapedString().c_str() << '"'; + inline NoLotTypeRules &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; - builder << ", "; - builder << R"("Symbol": )"; - builder << '"' << writer.getSymbolAsJsonEscapedString().c_str() << '"'; + return *this; + } - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } - builder << ", "; - builder << R"("SecurityType": )"; - builder << '"' << writer.getSecurityTypeAsJsonEscapedString().c_str() - << '"'; + #if __cplusplus < 201103L + template inline void forEach(Func& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - builder << ", "; - builder << R"("CFICode": )"; - builder << '"' << writer.getCFICodeAsJsonEscapedString().c_str() << '"'; + #else + template inline void forEach(Func&& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - builder << ", "; - builder << R"("MaturityMonthYear": )"; - builder << writer.maturityMonthYear(); + #endif - builder << ", "; - builder << R"("Currency": )"; - builder << '"' << writer.getCurrencyAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD static const char *LotTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("SecuritySubType": )"; - builder << '"' << writer.getSecuritySubTypeAsJsonEscapedString().c_str() - << '"'; + static SBE_CONSTEXPR std::uint16_t lotTypeId() SBE_NOEXCEPT + { + return 1093; + } - builder << ", "; - builder << R"("UserDefinedInstrument": )"; - if (std::isprint(writer.userDefinedInstrument())) { - builder << '"' << (char)writer.userDefinedInstrument() << '"'; - } else { - builder << (int)writer.userDefinedInstrument(); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lotTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - builder << ", "; - builder << R"("MatchAlgorithm": )"; - if (std::isprint(writer.matchAlgorithm())) { - builder << '"' << (char)writer.matchAlgorithm() << '"'; - } else { - builder << (int)writer.matchAlgorithm(); - } + SBE_NODISCARD bool lotTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= lotTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - builder << ", "; - builder << R"("MinTradeVol": )"; - builder << +writer.minTradeVol(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lotTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - builder << ", "; - builder << R"("MaxTradeVol": )"; - builder << +writer.maxTradeVol(); + static SBE_CONSTEXPR std::int8_t lotTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } - builder << ", "; - builder << R"("MinPriceIncrement": )"; - builder << writer.minPriceIncrement(); + static SBE_CONSTEXPR std::int8_t lotTypeMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } - builder << ", "; - builder << R"("DisplayFactor": )"; - builder << writer.displayFactor(); + static SBE_CONSTEXPR std::int8_t lotTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } - builder << ", "; - builder << R"("PriceDisplayFormat": )"; - builder << +writer.priceDisplayFormat(); + static SBE_CONSTEXPR std::size_t lotTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - builder << ", "; - builder << R"("PriceRatio": )"; - builder << writer.priceRatio(); + SBE_NODISCARD std::int8_t lotType() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int8_t)); + return (val); + } - builder << ", "; - builder << R"("TickRule": )"; - builder << +writer.tickRule(); + NoLotTypeRules &lotType(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int8_t)); + return *this; + } - builder << ", "; - builder << R"("UnitOfMeasure": )"; - builder << '"' << writer.getUnitOfMeasureAsJsonEscapedString().c_str() - << '"'; + SBE_NODISCARD static const char *MinLotSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("TradingReferencePrice": )"; - builder << writer.tradingReferencePrice(); + static SBE_CONSTEXPR std::uint16_t minLotSizeId() SBE_NOEXCEPT + { + return 1231; + } - builder << ", "; - builder << R"("SettlPriceType": )"; - builder << writer.settlPriceType(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minLotSizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - builder << ", "; - builder << R"("OpenInterestQty": )"; - builder << +writer.openInterestQty(); + SBE_NODISCARD bool minLotSizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= minLotSizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - builder << ", "; - builder << R"("ClearedVolume": )"; - builder << +writer.clearedVolume(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minLotSizeEncodingOffset() SBE_NOEXCEPT + { + return 1; + } - builder << ", "; - builder << R"("HighLimitPrice": )"; - builder << writer.highLimitPrice(); +private: + DecimalQty m_minLotSize; - builder << ", "; - builder << R"("LowLimitPrice": )"; - builder << writer.lowLimitPrice(); +public: + SBE_NODISCARD DecimalQty &minLotSize() + { + m_minLotSize.wrap(m_buffer, m_offset + 1, m_actingVersion, m_bufferLength); + return m_minLotSize; + } - builder << ", "; - builder << R"("MaxPriceVariation": )"; - builder << writer.maxPriceVariation(); + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoLotTypeRules writer) + { + builder << '{'; + builder << R"("LotType": )"; + builder << +writer.lotType(); - builder << ", "; - builder << R"("MainFraction": )"; - builder << +writer.mainFraction(); + builder << ", "; + builder << R"("MinLotSize": )"; + builder << writer.minLotSize(); - builder << ", "; - builder << R"("SubFraction": )"; - builder << +writer.subFraction(); + builder << '}'; - builder << ", "; - builder << R"("TradingReferenceDate": )"; - builder << +writer.tradingReferenceDate(); + return builder; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoEvents": [)"; - writer.noEvents().forEach([&](NoEvents &noEvents) { - if (atLeastOne) { - 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: + NoLotTypeRules m_noLotTypeRules; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoLotTypeRulesId() SBE_NOEXCEPT + { + return 1234; + } + + SBE_NODISCARD inline NoLotTypeRules &noLotTypeRules() + { + m_noLotTypeRules.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLotTypeRules; + } + + NoLotTypeRules &noLotTypeRulesCount(const std::uint8_t count) + { + m_noLotTypeRules.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLotTypeRules; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noLotTypeRulesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noLotTypeRulesInActingVersion() const SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= noLotTypeRulesSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + 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(18)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 18; + 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 18; + } + + 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() SBE_NOEXCEPT + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(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 *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 0; + } + + 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 + 0, 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 + 0, &val, sizeof(std::int32_t)); + return *this; + } + + 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 4; + } + + 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 }; + + return (const char *)legSecurityIDSourceValues; + } + + SBE_NODISCARD char legSecurityIDSource(const std::uint64_t index) const + { + static const std::uint8_t legSecurityIDSourceValues[] = { 56 }; + + 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 *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 4; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legSideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD LegSide::Value legSide() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint8_t)); + return LegSide::get((val)); + } + + NoLegs &legSide(const LegSide::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 4, &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 "Qty"; + case MetaAttribute::PRESENCE: return "required"; + 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 5; + } + + static SBE_CONSTEXPR std::int8_t legRatioQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t legRatioQtyMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t legRatioQtyMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t legRatioQtyEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::int8_t legRatioQty() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 5, sizeof(std::int8_t)); + return (val); + } + + NoLegs &legRatioQty(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 5, &val, sizeof(std::int8_t)); + return *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 6; + } + +private: + PRICENULL m_legPrice; + +public: + SBE_NODISCARD PRICENULL &legPrice() + { + m_legPrice.wrap(m_buffer, m_offset + 6, 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 "Qty"; + 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 14; + } + +private: + DecimalQty m_legOptionDelta; + +public: + SBE_NODISCARD DecimalQty &legOptionDelta() + { + m_legOptionDelta.wrap(m_buffer, m_offset + 14, m_actingVersion, m_bufferLength); + return m_legOptionDelta; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoLegs writer) + { + builder << '{'; + builder << R"("LegSecurityID": )"; + builder << +writer.legSecurityID(); + + builder << ", "; + builder << R"("LegSide": )"; + builder << '"' << writer.legSide() << '"'; + + builder << ", "; + builder << R"("LegRatioQty": )"; + builder << +writer.legRatioQty(); + + builder << ", "; + builder << R"("LegPrice": )"; + builder << writer.legPrice(); + + builder << ", "; + builder << R"("LegOptionDelta": )"; + builder << writer.legOptionDelta(); + + 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: + NoLegs m_noLegs; + +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; + } + + 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 bool noLegsInActingVersion() const SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= noLegsSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDInstrumentDefinitionSpread29 _writer) +{ + MDInstrumentDefinitionSpread29 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDInstrumentDefinitionSpread29", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); + + builder << ", "; + builder << R"("TotNumReports": )"; + builder << +writer.totNumReports(); + + builder << ", "; + builder << R"("SecurityUpdateAction": )"; + builder << '"' << writer.securityUpdateAction() << '"'; + + builder << ", "; + builder << R"("LastUpdateTime": )"; + builder << +writer.lastUpdateTime(); + + builder << ", "; + builder << R"("MDSecurityTradingStatus": )"; + builder << '"' << writer.mDSecurityTradingStatus() << '"'; + + builder << ", "; + builder << R"("ApplID": )"; + builder << +writer.applID(); + + builder << ", "; + builder << R"("MarketSegmentID": )"; + builder << +writer.marketSegmentID(); + + builder << ", "; + builder << R"("UnderlyingProduct": )"; + builder << +writer.underlyingProduct(); + + builder << ", "; + builder << R"("SecurityExchange": )"; + builder << '"' << + writer.getSecurityExchangeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityGroup": )"; + builder << '"' << + writer.getSecurityGroupAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("Asset": )"; + builder << '"' << + writer.getAssetAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("Symbol": )"; + builder << '"' << + writer.getSymbolAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("SecurityType": )"; + builder << '"' << + writer.getSecurityTypeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("CFICode": )"; + builder << '"' << + writer.getCFICodeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("MaturityMonthYear": )"; + builder << writer.maturityMonthYear(); + + builder << ", "; + builder << R"("Currency": )"; + builder << '"' << + writer.getCurrencyAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecuritySubType": )"; + builder << '"' << + writer.getSecuritySubTypeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("UserDefinedInstrument": )"; + if (std::isprint(writer.userDefinedInstrument())) + { + builder << '"' << (char)writer.userDefinedInstrument() << '"'; + } + else + { + builder << (int)writer.userDefinedInstrument(); + } + + builder << ", "; + builder << R"("MatchAlgorithm": )"; + if (std::isprint(writer.matchAlgorithm())) + { + builder << '"' << (char)writer.matchAlgorithm() << '"'; + } + else + { + builder << (int)writer.matchAlgorithm(); + } + + builder << ", "; + builder << R"("MinTradeVol": )"; + builder << +writer.minTradeVol(); + + builder << ", "; + builder << R"("MaxTradeVol": )"; + builder << +writer.maxTradeVol(); + + builder << ", "; + builder << R"("MinPriceIncrement": )"; + builder << writer.minPriceIncrement(); + + builder << ", "; + builder << R"("DisplayFactor": )"; + builder << writer.displayFactor(); + + builder << ", "; + builder << R"("PriceDisplayFormat": )"; + builder << +writer.priceDisplayFormat(); + + builder << ", "; + builder << R"("PriceRatio": )"; + builder << writer.priceRatio(); + + builder << ", "; + builder << R"("TickRule": )"; + builder << +writer.tickRule(); + + builder << ", "; + builder << R"("UnitOfMeasure": )"; + builder << '"' << + writer.getUnitOfMeasureAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("TradingReferencePrice": )"; + builder << writer.tradingReferencePrice(); + + builder << ", "; + builder << R"("SettlPriceType": )"; + builder << writer.settlPriceType(); + + builder << ", "; + builder << R"("OpenInterestQty": )"; + builder << +writer.openInterestQty(); + + builder << ", "; + builder << R"("ClearedVolume": )"; + builder << +writer.clearedVolume(); + + builder << ", "; + builder << R"("HighLimitPrice": )"; + builder << writer.highLimitPrice(); + + builder << ", "; + builder << R"("LowLimitPrice": )"; + builder << writer.lowLimitPrice(); + + builder << ", "; + builder << R"("MaxPriceVariation": )"; + builder << writer.maxPriceVariation(); + + builder << ", "; + builder << R"("MainFraction": )"; + builder << +writer.mainFraction(); + + builder << ", "; + builder << R"("SubFraction": )"; + builder << +writer.subFraction(); + + builder << ", "; + builder << R"("TradingReferenceDate": )"; + builder << +writer.tradingReferenceDate(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoEvents": [)"; + writer.noEvents().forEach([&](NoEvents& noEvents) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noEvents; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDFeedTypes": [)"; - writer.noMDFeedTypes().forEach([&](NoMDFeedTypes &noMDFeedTypes) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDFeedTypes": [)"; + writer.noMDFeedTypes().forEach([&](NoMDFeedTypes& noMDFeedTypes) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDFeedTypes; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoInstAttrib": [)"; - writer.noInstAttrib().forEach([&](NoInstAttrib &noInstAttrib) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoInstAttrib": [)"; + writer.noInstAttrib().forEach([&](NoInstAttrib& noInstAttrib) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noInstAttrib; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoLotTypeRules": [)"; - writer.noLotTypeRules().forEach([&](NoLotTypeRules &noLotTypeRules) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoLotTypeRules": [)"; + writer.noLotTypeRules().forEach([&](NoLotTypeRules& noLotTypeRules) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noLotTypeRules; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoLegs": [)"; - writer.noLegs().forEach([&](NoLegs &noLegs) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoLegs": [)"; + writer.noLegs().forEach([&](NoLegs& noLegs) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noLegs; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noEvents().forEach([](NoEvents e) + { + e.skip(); + }); + noMDFeedTypes().forEach([](NoMDFeedTypes e) + { + e.skip(); + }); + noInstAttrib().forEach([](NoInstAttrib e) + { + e.skip(); + }); + noLotTypeRules().forEach([](NoLotTypeRules e) + { + e.skip(); + }); + noLegs().forEach([](NoLegs e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noEventsLength = 0, + std::size_t noMDFeedTypesLength = 0, + std::size_t noInstAttribLength = 0, + std::size_t noLotTypeRulesLength = 0, + std::size_t noLegsLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoEvents::sbeHeaderSize(); + if (noEventsLength > 254LL) + { + throw std::runtime_error("noEventsLength outside of allowed range [E110]"); + } + length += noEventsLength *NoEvents::sbeBlockLength(); + + length += NoMDFeedTypes::sbeHeaderSize(); + if (noMDFeedTypesLength > 254LL) + { + throw std::runtime_error("noMDFeedTypesLength outside of allowed range [E110]"); + } + length += noMDFeedTypesLength *NoMDFeedTypes::sbeBlockLength(); + + length += NoInstAttrib::sbeHeaderSize(); + if (noInstAttribLength > 254LL) + { + throw std::runtime_error("noInstAttribLength outside of allowed range [E110]"); + } + length += noInstAttribLength *NoInstAttrib::sbeBlockLength(); + + length += NoLotTypeRules::sbeHeaderSize(); + if (noLotTypeRulesLength > 254LL) + { + throw std::runtime_error("noLotTypeRulesLength outside of allowed range [E110]"); + } + length += noLotTypeRulesLength *NoLotTypeRules::sbeBlockLength(); + + length += NoLegs::sbeHeaderSize(); + if (noLegsLength > 254LL) + { + throw std::runtime_error("noLegsLength outside of allowed range [E110]"); + } + length += noLegsLength *NoLegs::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionSpread56.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionSpread56.h index ec6295b72..b6f679c67 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionSpread56.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDInstrumentDefinitionSpread56.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,6079 +86,6645 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class MDInstrumentDefinitionSpread56 { - 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 MDInstrumentDefinitionSpread56 +{ +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; } + 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(195); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(56); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - MDInstrumentDefinitionSpread56() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - MDInstrumentDefinitionSpread56( - 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; - MDInstrumentDefinitionSpread56( - char *buffer, const std::uint64_t bufferLength) - : MDInstrumentDefinitionSpread56( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + MDInstrumentDefinitionSpread56() = default; - MDInstrumentDefinitionSpread56( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : MDInstrumentDefinitionSpread56( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + MDInstrumentDefinitionSpread56( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)195; - } + MDInstrumentDefinitionSpread56(char *buffer, const std::uint64_t bufferLength) : + MDInstrumentDefinitionSpread56(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)56; - } + MDInstrumentDefinitionSpread56( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + MDInstrumentDefinitionSpread56(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(195); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "d"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(56); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - MDInstrumentDefinitionSpread56 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = MDInstrumentDefinitionSpread56( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MDInstrumentDefinitionSpread56 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "d"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = MDInstrumentDefinitionSpread56( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + MDInstrumentDefinitionSpread56 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = MDInstrumentDefinitionSpread56(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - MDInstrumentDefinitionSpread56 &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 = MDInstrumentDefinitionSpread56( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + MDInstrumentDefinitionSpread56 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = MDInstrumentDefinitionSpread56( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + MDInstrumentDefinitionSpread56 &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 = MDInstrumentDefinitionSpread56(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + MDInstrumentDefinitionSpread56 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char *MatchEventIndicatorMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "MultipleCharValue"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char * - TotNumReportsMetaAttribute(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 *TotNumReportsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT { - return 911; - } + static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT + { + return 911; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totNumReportsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t totNumReportsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= totNumReportsSinceVersion(); + return m_actingVersion >= totNumReportsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totNumReportsEncodingOffset() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t totNumReportsEncodingOffset() SBE_NOEXCEPT + { + return 1; + } - static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT { - return 4294967295; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT + { + return UINT32_C(0xffffffff); + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t totNumReports() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t totNumReports() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionSpread56 & - totNumReports(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint32_t)); - return *this; - } + MDInstrumentDefinitionSpread56 &totNumReports(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char *SecurityUpdateActionMetaAttribute( - 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 *SecurityUpdateActionMetaAttribute(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 securityUpdateActionId() SBE_NOEXCEPT { - return 980; - } + static SBE_CONSTEXPR std::uint16_t securityUpdateActionId() SBE_NOEXCEPT + { + return 980; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityUpdateActionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityUpdateActionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityUpdateActionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityUpdateActionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityUpdateActionSinceVersion(); + return m_actingVersion >= securityUpdateActionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityUpdateActionEncodingOffset() SBE_NOEXCEPT { - return 5; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityUpdateActionEncodingOffset() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityUpdateActionEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityUpdateActionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SecurityUpdateAction::Value - securityUpdateAction() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 5, sizeof(char)); - return SecurityUpdateAction::get((val)); - } + SBE_NODISCARD SecurityUpdateAction::Value securityUpdateAction() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 5, sizeof(char)); + return SecurityUpdateAction::get((val)); + } - MDInstrumentDefinitionSpread56 & - securityUpdateAction(const SecurityUpdateAction::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 5, &val, sizeof(char)); - return *this; - } + MDInstrumentDefinitionSpread56 &securityUpdateAction(const SecurityUpdateAction::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 5, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char * - LastUpdateTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LastUpdateTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t lastUpdateTimeId() SBE_NOEXCEPT { - return 779; - } + static SBE_CONSTEXPR std::uint16_t lastUpdateTimeId() SBE_NOEXCEPT + { + return 779; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastUpdateTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastUpdateTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lastUpdateTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lastUpdateTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastUpdateTimeSinceVersion(); + return m_actingVersion >= lastUpdateTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastUpdateTimeEncodingOffset() SBE_NOEXCEPT { - return 6; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastUpdateTimeEncodingOffset() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - lastUpdateTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t lastUpdateTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t lastUpdateTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 6, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } + SBE_NODISCARD std::uint64_t lastUpdateTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 6, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - MDInstrumentDefinitionSpread56 & - lastUpdateTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 6, &val, sizeof(std::uint64_t)); - return *this; - } + MDInstrumentDefinitionSpread56 &lastUpdateTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 6, &val, sizeof(std::uint64_t)); + return *this; + } - SBE_NODISCARD static const char *MDSecurityTradingStatusMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MDSecurityTradingStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mDSecurityTradingStatusId() SBE_NOEXCEPT { - return 1682; - } + static SBE_CONSTEXPR std::uint16_t mDSecurityTradingStatusId() SBE_NOEXCEPT + { + return 1682; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDSecurityTradingStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDSecurityTradingStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mDSecurityTradingStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mDSecurityTradingStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDSecurityTradingStatusSinceVersion(); + return m_actingVersion >= mDSecurityTradingStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDSecurityTradingStatusEncodingOffset() SBE_NOEXCEPT { - return 14; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDSecurityTradingStatusEncodingOffset() SBE_NOEXCEPT + { + return 14; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDSecurityTradingStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDSecurityTradingStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SecurityTradingStatus::Value - mDSecurityTradingStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); - return SecurityTradingStatus::get((val)); - } + SBE_NODISCARD SecurityTradingStatus::Value mDSecurityTradingStatus() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 14, sizeof(std::uint8_t)); + return SecurityTradingStatus::get((val)); + } - MDInstrumentDefinitionSpread56 &mDSecurityTradingStatus( - const SecurityTradingStatus::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionSpread56 &mDSecurityTradingStatus(const SecurityTradingStatus::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 14, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - ApplIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ApplIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t applIDId() SBE_NOEXCEPT { return 1180; } + static SBE_CONSTEXPR std::uint16_t applIDId() SBE_NOEXCEPT + { + return 1180; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - applIDSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t applIDSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool applIDInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool applIDInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= applIDSinceVersion(); + return m_actingVersion >= applIDSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - applIDEncodingOffset() SBE_NOEXCEPT { - return 15; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t applIDEncodingOffset() SBE_NOEXCEPT + { + return 15; + } - static SBE_CONSTEXPR std::int16_t applIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT16; - } + static SBE_CONSTEXPR std::int16_t applIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT16; + } - static SBE_CONSTEXPR std::int16_t applIDMinValue() SBE_NOEXCEPT { - return (std::int16_t)-32767; - } + static SBE_CONSTEXPR std::int16_t applIDMinValue() SBE_NOEXCEPT + { + return static_cast(-32767); + } - static SBE_CONSTEXPR std::int16_t applIDMaxValue() SBE_NOEXCEPT { - return (std::int16_t)32767; - } + static SBE_CONSTEXPR std::int16_t applIDMaxValue() SBE_NOEXCEPT + { + return static_cast(32767); + } - static SBE_CONSTEXPR std::size_t applIDEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t applIDEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::int16_t applID() const SBE_NOEXCEPT { - std::int16_t val; - std::memcpy(&val, m_buffer + m_offset + 15, sizeof(std::int16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::int16_t applID() const SBE_NOEXCEPT + { + std::int16_t val; + std::memcpy(&val, m_buffer + m_offset + 15, sizeof(std::int16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - MDInstrumentDefinitionSpread56 & - applID(const std::int16_t value) SBE_NOEXCEPT { - std::int16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 15, &val, sizeof(std::int16_t)); - return *this; - } + MDInstrumentDefinitionSpread56 &applID(const std::int16_t value) SBE_NOEXCEPT + { + std::int16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 15, &val, sizeof(std::int16_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 "required"; - 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 "required"; + 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 17; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t marketSegmentIDEncodingOffset() SBE_NOEXCEPT + { + return 17; + } - static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT8; - } + static SBE_CONSTEXPR std::uint8_t marketSegmentIDNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT8; + } - 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 + 17, 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 + 17, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionSpread56 & - marketSegmentID(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionSpread56 &marketSegmentID(const std::uint8_t 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 *UnderlyingProductMetaAttribute( - 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 *UnderlyingProductMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t underlyingProductId() SBE_NOEXCEPT { - return 462; - } + static SBE_CONSTEXPR std::uint16_t underlyingProductId() SBE_NOEXCEPT + { + return 462; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - underlyingProductSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t underlyingProductSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool underlyingProductInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool underlyingProductInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= underlyingProductSinceVersion(); + return m_actingVersion >= underlyingProductSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - underlyingProductEncodingOffset() SBE_NOEXCEPT { - return 18; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t underlyingProductEncodingOffset() SBE_NOEXCEPT + { + return 18; + } - static SBE_CONSTEXPR std::uint8_t underlyingProductNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t underlyingProductNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t underlyingProductMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t underlyingProductMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t underlyingProductMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t underlyingProductMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - underlyingProductEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t underlyingProductEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t underlyingProduct() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t underlyingProduct() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 18, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionSpread56 & - underlyingProduct(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; - } + MDInstrumentDefinitionSpread56 &underlyingProduct(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 static const char *SecurityExchangeMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Exchange"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityExchangeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Exchange"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityExchangeId() SBE_NOEXCEPT { - return 207; - } + static SBE_CONSTEXPR std::uint16_t securityExchangeId() SBE_NOEXCEPT + { + return 207; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityExchangeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityExchangeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityExchangeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityExchangeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityExchangeSinceVersion(); + return m_actingVersion >= securityExchangeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityExchangeEncodingOffset() SBE_NOEXCEPT { - return 19; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityExchangeEncodingOffset() SBE_NOEXCEPT + { + return 19; + } - static SBE_CONSTEXPR char securityExchangeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityExchangeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityExchangeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityExchangeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityExchangeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char securityExchangeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - securityExchangeEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t securityExchangeEncodingLength() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint64_t securityExchangeLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::uint64_t securityExchangeLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD const char *securityExchange() const SBE_NOEXCEPT { - return m_buffer + m_offset + 19; - } + SBE_NODISCARD const char *securityExchange() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 19; + } - SBE_NODISCARD char *securityExchange() SBE_NOEXCEPT { - return m_buffer + m_offset + 19; - } + SBE_NODISCARD char *securityExchange() SBE_NOEXCEPT + { + return m_buffer + m_offset + 19; + } - SBE_NODISCARD char securityExchange(const std::uint64_t index) const { - if (index >= 4) { - throw std::runtime_error( - "index out of range for securityExchange [E104]"); - } + SBE_NODISCARD char securityExchange(const std::uint64_t index) const + { + if (index >= 4) + { + throw std::runtime_error("index out of range for securityExchange [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 19 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 19 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread56 & - securityExchange(const std::uint64_t index, const char value) { - if (index >= 4) { - throw std::runtime_error( - "index out of range for securityExchange [E105]"); - } + MDInstrumentDefinitionSpread56 &securityExchange(const std::uint64_t index, const char value) + { + if (index >= 4) + { + throw std::runtime_error("index out of range for securityExchange [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 19 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 19 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSecurityExchange(char *const dst, const std::uint64_t length) const { - if (length > 4) { - throw std::runtime_error( - "length too large for getSecurityExchange [E106]"); - } + std::uint64_t getSecurityExchange(char *const dst, const std::uint64_t length) const + { + if (length > 4) + { + throw std::runtime_error("length too large for getSecurityExchange [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 19, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 19, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionSpread56 & - putSecurityExchange(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 19, src, sizeof(char) * 4); - return *this; - } + MDInstrumentDefinitionSpread56 &putSecurityExchange(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 19, src, sizeof(char) * 4); + return *this; + } - MDInstrumentDefinitionSpread56 &putSecurityExchange( - const char value0, - const char value1, - const char value2, - const char value3) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 19, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 20, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 21, &val2, sizeof(char)); - char val3 = (value3); - std::memcpy(m_buffer + m_offset + 22, &val3, sizeof(char)); + MDInstrumentDefinitionSpread56 &putSecurityExchange( + const char value0, + const char value1, + const char value2, + const char value3) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 19, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 20, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 21, &val2, sizeof(char)); + char val3 = (value3); + std::memcpy(m_buffer + m_offset + 22, &val3, sizeof(char)); - return *this; - } + return *this; + } - std::string getSecurityExchangeAsString() const { - const char *buffer = m_buffer + m_offset + 19; - size_t length = 0; + SBE_NODISCARD std::string getSecurityExchangeAsString() const + { + const char *buffer = m_buffer + m_offset + 19; + size_t length = 0; - for (; length < 4 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 4 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getSecurityExchangeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityExchangeAsString(); + std::string getSecurityExchangeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityExchangeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityExchangeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 19; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityExchangeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 19; + size_t length = 0; - for (; length < 4 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 4 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - MDInstrumentDefinitionSpread56 & - putSecurityExchange(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 4) { - throw std::runtime_error( - "string too large for putSecurityExchange [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionSpread56 &putSecurityExchange(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 4) + { + throw std::runtime_error("string too large for putSecurityExchange [E106]"); + } - std::memcpy(m_buffer + m_offset + 19, str.data(), srcLength); - for (size_t start = srcLength; start < 4; ++start) { - m_buffer[m_offset + 19 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 19, str.data(), srcLength); + for (size_t start = srcLength; start < 4; ++start) + { + m_buffer[m_offset + 19 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionSpread56 &putSecurityExchange(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 4) { - throw std::runtime_error( - "string too large for putSecurityExchange [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionSpread56 &putSecurityExchange(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 4) + { + throw std::runtime_error("string too large for putSecurityExchange [E106]"); + } - std::memcpy(m_buffer + m_offset + 19, str.c_str(), srcLength); - for (size_t start = srcLength; start < 4; ++start) { - m_buffer[m_offset + 19 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 19, str.c_str(), srcLength); + for (size_t start = srcLength; start < 4; ++start) + { + m_buffer[m_offset + 19 + start] = 0; + } - return *this; - } -#endif + return *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 "required"; - 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 "required"; + 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 23; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityGroupEncodingOffset() SBE_NOEXCEPT + { + return 23; + } - 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 + 23; - } + SBE_NODISCARD const char *securityGroup() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 23; + } - SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT { - return m_buffer + m_offset + 23; - } + SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT + { + return m_buffer + m_offset + 23; + } - 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 + 23 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 23 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread56 & - securityGroup(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E105]"); - } + MDInstrumentDefinitionSpread56 &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 + 23 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 23 + (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 + 23, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 23, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionSpread56 & - putSecurityGroup(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 23, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionSpread56 &putSecurityGroup(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 23, src, sizeof(char) * 6); + return *this; + } - std::string getSecurityGroupAsString() const { - const char *buffer = m_buffer + m_offset + 23; - size_t length = 0; + SBE_NODISCARD std::string getSecurityGroupAsString() const + { + const char *buffer = m_buffer + m_offset + 23; + 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 (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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityGroupAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 23; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 23; + 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 - MDInstrumentDefinitionSpread56 & - 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 + MDInstrumentDefinitionSpread56 &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 + 23, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 23 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 23, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 23 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionSpread56 &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 + MDInstrumentDefinitionSpread56 &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 + 23, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 23 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 23, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 23 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - AssetMetaAttribute(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 *AssetMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t assetId() SBE_NOEXCEPT { return 6937; } + static SBE_CONSTEXPR std::uint16_t assetId() SBE_NOEXCEPT + { + return 6937; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - assetSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t assetSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool assetInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool assetInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= assetSinceVersion(); + return m_actingVersion >= assetSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - assetEncodingOffset() SBE_NOEXCEPT { - return 29; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t assetEncodingOffset() SBE_NOEXCEPT + { + return 29; + } - static SBE_CONSTEXPR char assetNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char assetNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char assetMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char assetMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char assetMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char assetMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t assetEncodingLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::size_t assetEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t assetLength() SBE_NOEXCEPT { return 6; } + static SBE_CONSTEXPR std::uint64_t assetLength() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD const char *asset() const SBE_NOEXCEPT { - return m_buffer + m_offset + 29; - } + SBE_NODISCARD const char *asset() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 29; + } - SBE_NODISCARD char *asset() SBE_NOEXCEPT { return m_buffer + m_offset + 29; } + SBE_NODISCARD char *asset() SBE_NOEXCEPT + { + return m_buffer + m_offset + 29; + } - SBE_NODISCARD char asset(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for asset [E104]"); - } + SBE_NODISCARD char asset(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for asset [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 29 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 29 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread56 & - asset(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for asset [E105]"); - } + MDInstrumentDefinitionSpread56 &asset(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for asset [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 29 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 29 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getAsset(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error("length too large for getAsset [E106]"); - } + std::uint64_t getAsset(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getAsset [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 29, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 29, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionSpread56 & - putAsset(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 29, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionSpread56 &putAsset(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 29, src, sizeof(char) * 6); + return *this; + } - std::string getAssetAsString() const { - const char *buffer = m_buffer + m_offset + 29; - size_t length = 0; + SBE_NODISCARD std::string getAssetAsString() const + { + const char *buffer = m_buffer + m_offset + 29; + 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 getAssetAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getAssetAsString(); + std::string getAssetAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getAssetAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getAssetAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 29; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getAssetAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 29; + 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 - MDInstrumentDefinitionSpread56 &putAsset(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putAsset [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionSpread56 &putAsset(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putAsset [E106]"); + } - std::memcpy(m_buffer + m_offset + 29, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 29 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 29, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 29 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionSpread56 &putAsset(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putAsset [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionSpread56 &putAsset(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putAsset [E106]"); + } - std::memcpy(m_buffer + m_offset + 29, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 29 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 29, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 29 + start] = 0; + } - return *this; - } -#endif + 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 "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SymbolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t symbolId() SBE_NOEXCEPT { return 55; } + 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 static SBE_CONSTEXPR std::uint64_t symbolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool symbolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool symbolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= symbolSinceVersion(); + return m_actingVersion >= symbolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - symbolEncodingOffset() SBE_NOEXCEPT { - return 35; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t symbolEncodingOffset() SBE_NOEXCEPT + { + return 35; + } - static SBE_CONSTEXPR char symbolNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char symbolNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char symbolMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char symbolMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char symbolMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char symbolMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t symbolEncodingLength() SBE_NOEXCEPT { - return 20; - } + static SBE_CONSTEXPR std::size_t symbolEncodingLength() SBE_NOEXCEPT + { + return 20; + } - static SBE_CONSTEXPR std::uint64_t symbolLength() 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 + 35; - } + SBE_NODISCARD const char *symbol() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 35; + } - SBE_NODISCARD char *symbol() SBE_NOEXCEPT { - return m_buffer + m_offset + 35; - } + SBE_NODISCARD char *symbol() SBE_NOEXCEPT + { + return m_buffer + m_offset + 35; + } - SBE_NODISCARD char symbol(const std::uint64_t index) const { - if (index >= 20) { - throw std::runtime_error("index out of range for symbol [E104]"); - } + 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 + 35 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 35 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread56 & - symbol(const std::uint64_t index, const char value) { - if (index >= 20) { - throw std::runtime_error("index out of range for symbol [E105]"); - } + MDInstrumentDefinitionSpread56 &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 + 35 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 35 + (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::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 + 35, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 35, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionSpread56 & - putSymbol(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 35, src, sizeof(char) * 20); - return *this; - } + MDInstrumentDefinitionSpread56 &putSymbol(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 35, src, sizeof(char) * 20); + return *this; + } - std::string getSymbolAsString() const { - const char *buffer = m_buffer + m_offset + 35; - size_t length = 0; + SBE_NODISCARD std::string getSymbolAsString() const + { + const char *buffer = m_buffer + m_offset + 35; + 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 getSymbolAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSymbolAsString(); + std::string getSymbolAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSymbolAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSymbolAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 35; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSymbolAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 35; + 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 - MDInstrumentDefinitionSpread56 &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]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionSpread56 &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 + 35, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 35 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 35, str.data(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 35 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionSpread56 &putSymbol(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 20) { - throw std::runtime_error("string too large for putSymbol [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionSpread56 &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 + 35, str.c_str(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 35 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 35, str.c_str(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 35 + 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 55; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 55; + } - 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 + 55, 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 + 55, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionSpread56 & - securityID(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 55, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionSpread56 &securityID(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 55, &val, sizeof(std::int32_t)); + return *this; + } - 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 ""; - } - } + 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; - } + 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 static SBE_CONSTEXPR std::uint64_t securityIDSourceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityIDSourceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityIDSourceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityIDSourceSinceVersion(); + return m_actingVersion >= securityIDSourceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityIDSourceEncodingOffset() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDSourceEncodingOffset() SBE_NOEXCEPT + { + return 59; + } - static SBE_CONSTEXPR char securityIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityIDSourceNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityIDSourceMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityIDSourceMaxValue() SBE_NOEXCEPT { - return (char)126; - } + 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::size_t securityIDSourceEncodingLength() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint64_t securityIDSourceLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::uint64_t securityIDSourceLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD const char *securityIDSource() const { - static const std::uint8_t securityIDSourceValues[] = {56}; + SBE_NODISCARD const char *securityIDSource() const + { + static const std::uint8_t securityIDSourceValues[] = { 56 }; - return (const char *)securityIDSourceValues; - } + return (const char *)securityIDSourceValues; + } - SBE_NODISCARD char securityIDSource(const std::uint64_t index) const { - static const std::uint8_t securityIDSourceValues[] = {56}; + SBE_NODISCARD char securityIDSource(const std::uint64_t index) const + { + static const std::uint8_t securityIDSourceValues[] = { 56 }; - return (char)securityIDSourceValues[index]; - } + 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::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::memcpy(dst, securityIDSourceValues, static_cast(bytesToCopy)); + return bytesToCopy; + } - std::string getSecurityIDSourceAsString() const { - static const std::uint8_t SecurityIDSourceValues[] = {56}; + std::string getSecurityIDSourceAsString() const + { + static const std::uint8_t SecurityIDSourceValues[] = { 56 }; - return std::string((const char *)SecurityIDSourceValues, 1); - } + return std::string((const char *)SecurityIDSourceValues, 1); + } - std::string getSecurityIDSourceAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityIDSourceAsString(); + std::string getSecurityIDSourceAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityIDSourceAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 * - SecurityTypeMetaAttribute(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 *SecurityTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityTypeId() SBE_NOEXCEPT { - return 167; - } + 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 static SBE_CONSTEXPR std::uint64_t securityTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityTypeSinceVersion(); + return m_actingVersion >= securityTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityTypeEncodingOffset() SBE_NOEXCEPT { - return 59; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityTypeEncodingOffset() SBE_NOEXCEPT + { + return 59; + } - static SBE_CONSTEXPR char securityTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securityTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securityTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securityTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securityTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + 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::size_t securityTypeEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t securityTypeLength() 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 + 59; - } + SBE_NODISCARD const char *securityType() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 59; + } - SBE_NODISCARD char *securityType() SBE_NOEXCEPT { - return m_buffer + m_offset + 59; - } + SBE_NODISCARD char *securityType() SBE_NOEXCEPT + { + return m_buffer + m_offset + 59; + } - SBE_NODISCARD char securityType(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for securityType [E104]"); - } + 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 + 59 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 59 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread56 & - securityType(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for securityType [E105]"); - } + MDInstrumentDefinitionSpread56 &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 + 59 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 59 + (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::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 + 59, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 59, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionSpread56 & - putSecurityType(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 59, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionSpread56 &putSecurityType(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 59, src, sizeof(char) * 6); + return *this; + } - std::string getSecurityTypeAsString() const { - const char *buffer = m_buffer + m_offset + 59; - size_t length = 0; + SBE_NODISCARD std::string getSecurityTypeAsString() const + { + const char *buffer = m_buffer + m_offset + 59; + 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 getSecurityTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecurityTypeAsString(); + std::string getSecurityTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecurityTypeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityTypeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 59; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityTypeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 59; + 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 - MDInstrumentDefinitionSpread56 &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]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionSpread56 &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 + 59, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 59 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 59, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 59 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionSpread56 &putSecurityType(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error( - "string too large for putSecurityType [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionSpread56 &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 + 59, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 59 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 59, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 59 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - CFICodeMetaAttribute(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 *CFICodeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t cFICodeId() SBE_NOEXCEPT { return 461; } + static SBE_CONSTEXPR std::uint16_t cFICodeId() SBE_NOEXCEPT + { + return 461; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - cFICodeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t cFICodeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool cFICodeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool cFICodeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= cFICodeSinceVersion(); + return m_actingVersion >= cFICodeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - cFICodeEncodingOffset() SBE_NOEXCEPT { - return 65; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t cFICodeEncodingOffset() SBE_NOEXCEPT + { + return 65; + } - static SBE_CONSTEXPR char cFICodeNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char cFICodeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char cFICodeMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char cFICodeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char cFICodeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char cFICodeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t cFICodeEncodingLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::size_t cFICodeEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t cFICodeLength() SBE_NOEXCEPT { return 6; } + static SBE_CONSTEXPR std::uint64_t cFICodeLength() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD const char *cFICode() const SBE_NOEXCEPT { - return m_buffer + m_offset + 65; - } + SBE_NODISCARD const char *cFICode() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 65; + } - SBE_NODISCARD char *cFICode() SBE_NOEXCEPT { - return m_buffer + m_offset + 65; - } + SBE_NODISCARD char *cFICode() SBE_NOEXCEPT + { + return m_buffer + m_offset + 65; + } - SBE_NODISCARD char cFICode(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for cFICode [E104]"); - } + SBE_NODISCARD char cFICode(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for cFICode [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); + } - MDInstrumentDefinitionSpread56 & - cFICode(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for cFICode [E105]"); - } + MDInstrumentDefinitionSpread56 &cFICode(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for cFICode [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 getCFICode(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error("length too large for getCFICode [E106]"); - } + std::uint64_t getCFICode(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getCFICode [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; + } - MDInstrumentDefinitionSpread56 & - putCFICode(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 65, src, sizeof(char) * 6); - return *this; - } + MDInstrumentDefinitionSpread56 &putCFICode(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 65, src, sizeof(char) * 6); + return *this; + } - std::string getCFICodeAsString() const { - const char *buffer = m_buffer + m_offset + 65; - size_t length = 0; + SBE_NODISCARD std::string getCFICodeAsString() const + { + const char *buffer = m_buffer + m_offset + 65; + 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 getCFICodeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCFICodeAsString(); + std::string getCFICodeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCFICodeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getCFICodeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 65; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCFICodeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 65; + 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 - MDInstrumentDefinitionSpread56 &putCFICode(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putCFICode [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionSpread56 &putCFICode(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putCFICode [E106]"); + } - std::memcpy(m_buffer + m_offset + 65, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 65 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 65, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 65 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionSpread56 &putCFICode(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putCFICode [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionSpread56 &putCFICode(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putCFICode [E106]"); + } - std::memcpy(m_buffer + m_offset + 65, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 65 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 65, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 65 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - 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 ""; - } - } + 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; - } + 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 static SBE_CONSTEXPR std::uint64_t maturityMonthYearSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool maturityMonthYearInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool maturityMonthYearInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= maturityMonthYearSinceVersion(); + return m_actingVersion >= maturityMonthYearSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maturityMonthYearEncodingOffset() SBE_NOEXCEPT { - return 71; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maturityMonthYearEncodingOffset() SBE_NOEXCEPT + { + return 71; + } - private: - MaturityMonthYear m_maturityMonthYear; +private: + MaturityMonthYear m_maturityMonthYear; - public: - SBE_NODISCARD MaturityMonthYear &maturityMonthYear() { - m_maturityMonthYear.wrap( - m_buffer, m_offset + 71, m_actingVersion, m_bufferLength); - return m_maturityMonthYear; - } +public: + SBE_NODISCARD MaturityMonthYear &maturityMonthYear() + { + m_maturityMonthYear.wrap(m_buffer, m_offset + 71, m_actingVersion, m_bufferLength); + return m_maturityMonthYear; + } - SBE_NODISCARD static const char * - CurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Currency"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CurrencyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Currency"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t currencyId() SBE_NOEXCEPT { return 15; } + 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 static SBE_CONSTEXPR std::uint64_t currencySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool currencyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool currencyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= currencySinceVersion(); + return m_actingVersion >= currencySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - currencyEncodingOffset() SBE_NOEXCEPT { - return 76; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t currencyEncodingOffset() SBE_NOEXCEPT + { + return 76; + } - static SBE_CONSTEXPR char currencyNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char currencyNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char currencyMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char currencyMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char currencyMaxValue() SBE_NOEXCEPT { - return (char)126; - } + 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::size_t currencyEncodingLength() SBE_NOEXCEPT + { + return 3; + } - static SBE_CONSTEXPR std::uint64_t currencyLength() 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 + 76; - } + SBE_NODISCARD const char *currency() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 76; + } - SBE_NODISCARD char *currency() SBE_NOEXCEPT { - return m_buffer + m_offset + 76; - } + SBE_NODISCARD char *currency() SBE_NOEXCEPT + { + return m_buffer + m_offset + 76; + } - SBE_NODISCARD char currency(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error("index out of range for currency [E104]"); - } + 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 + 76 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 76 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread56 & - currency(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error("index out of range for currency [E105]"); - } + MDInstrumentDefinitionSpread56 ¤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 + 76 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 76 + (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::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 + 76, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 76, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionSpread56 & - putCurrency(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 76, src, sizeof(char) * 3); - return *this; - } + MDInstrumentDefinitionSpread56 &putCurrency(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 76, src, sizeof(char) * 3); + return *this; + } - MDInstrumentDefinitionSpread56 &putCurrency( - const char value0, const char value1, const char value2) SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 76, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 77, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 78, &val2, sizeof(char)); + MDInstrumentDefinitionSpread56 &putCurrency( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 76, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 77, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 78, &val2, sizeof(char)); - return *this; - } + return *this; + } - std::string getCurrencyAsString() const { - const char *buffer = m_buffer + m_offset + 76; - size_t length = 0; + SBE_NODISCARD std::string getCurrencyAsString() const + { + const char *buffer = m_buffer + m_offset + 76; + 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 getCurrencyAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getCurrencyAsString(); + std::string getCurrencyAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getCurrencyAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getCurrencyAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 76; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getCurrencyAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 76; + 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 - MDInstrumentDefinitionSpread56 &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]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionSpread56 &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 + 76, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 76 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 76, str.data(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 76 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionSpread56 &putCurrency(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error("string too large for putCurrency [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionSpread56 &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 + 76, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 76 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 76, str.c_str(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 76 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - 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 ""; - } - } + 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; - } + 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 static SBE_CONSTEXPR std::uint64_t securitySubTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securitySubTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securitySubTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securitySubTypeSinceVersion(); + return m_actingVersion >= securitySubTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securitySubTypeEncodingOffset() SBE_NOEXCEPT { - return 79; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securitySubTypeEncodingOffset() SBE_NOEXCEPT + { + return 79; + } - static SBE_CONSTEXPR char securitySubTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char securitySubTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char securitySubTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char securitySubTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char securitySubTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char securitySubTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - securitySubTypeEncodingLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::size_t securitySubTypeEncodingLength() SBE_NOEXCEPT + { + return 5; + } - static SBE_CONSTEXPR std::uint64_t securitySubTypeLength() SBE_NOEXCEPT { - return 5; - } + static SBE_CONSTEXPR std::uint64_t securitySubTypeLength() SBE_NOEXCEPT + { + return 5; + } - SBE_NODISCARD const char *securitySubType() const SBE_NOEXCEPT { - return m_buffer + m_offset + 79; - } + SBE_NODISCARD const char *securitySubType() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 79; + } - SBE_NODISCARD char *securitySubType() SBE_NOEXCEPT { - return m_buffer + m_offset + 79; - } + SBE_NODISCARD char *securitySubType() SBE_NOEXCEPT + { + return m_buffer + m_offset + 79; + } - SBE_NODISCARD char securitySubType(const std::uint64_t index) const { - if (index >= 5) { - throw std::runtime_error( - "index out of range for securitySubType [E104]"); - } + SBE_NODISCARD char securitySubType(const std::uint64_t index) const + { + if (index >= 5) + { + throw std::runtime_error("index out of range for securitySubType [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 79 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 79 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread56 & - securitySubType(const std::uint64_t index, const char value) { - if (index >= 5) { - throw std::runtime_error( - "index out of range for securitySubType [E105]"); - } + MDInstrumentDefinitionSpread56 &securitySubType(const std::uint64_t index, const char value) + { + if (index >= 5) + { + throw std::runtime_error("index out of range for securitySubType [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 79 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 79 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getSecuritySubType(char *const dst, const std::uint64_t length) const { - if (length > 5) { - throw std::runtime_error( - "length too large for getSecuritySubType [E106]"); - } + std::uint64_t getSecuritySubType(char *const dst, const std::uint64_t length) const + { + if (length > 5) + { + throw std::runtime_error("length too large for getSecuritySubType [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 79, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 79, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionSpread56 & - putSecuritySubType(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 79, src, sizeof(char) * 5); - return *this; - } + MDInstrumentDefinitionSpread56 &putSecuritySubType(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 79, src, sizeof(char) * 5); + return *this; + } - std::string getSecuritySubTypeAsString() const { - const char *buffer = m_buffer + m_offset + 79; - size_t length = 0; + SBE_NODISCARD std::string getSecuritySubTypeAsString() const + { + const char *buffer = m_buffer + m_offset + 79; + 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 getSecuritySubTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSecuritySubTypeAsString(); + std::string getSecuritySubTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getSecuritySubTypeAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecuritySubTypeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 79; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecuritySubTypeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 79; + 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 - MDInstrumentDefinitionSpread56 & - putSecuritySubType(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error( - "string too large for putSecuritySubType [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionSpread56 &putSecuritySubType(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putSecuritySubType [E106]"); + } - std::memcpy(m_buffer + m_offset + 79, str.data(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 79 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 79, str.data(), srcLength); + for (size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 79 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionSpread56 &putSecuritySubType(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 5) { - throw std::runtime_error( - "string too large for putSecuritySubType [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionSpread56 &putSecuritySubType(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 5) + { + throw std::runtime_error("string too large for putSecuritySubType [E106]"); + } - std::memcpy(m_buffer + m_offset + 79, str.c_str(), srcLength); - for (size_t start = srcLength; start < 5; ++start) { - m_buffer[m_offset + 79 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 79, str.c_str(), srcLength); + for (size_t start = srcLength; start < 5; ++start) + { + m_buffer[m_offset + 79 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *UserDefinedInstrumentMetaAttribute( - 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 *UserDefinedInstrumentMetaAttribute(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 userDefinedInstrumentId() SBE_NOEXCEPT { - return 9779; - } + 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 static SBE_CONSTEXPR std::uint64_t userDefinedInstrumentSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool userDefinedInstrumentInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool userDefinedInstrumentInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= userDefinedInstrumentSinceVersion(); + return m_actingVersion >= userDefinedInstrumentSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - userDefinedInstrumentEncodingOffset() SBE_NOEXCEPT { - return 84; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t userDefinedInstrumentEncodingOffset() SBE_NOEXCEPT + { + return 84; + } - static SBE_CONSTEXPR char userDefinedInstrumentNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char userDefinedInstrumentNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char userDefinedInstrumentMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char userDefinedInstrumentMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char userDefinedInstrumentMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char userDefinedInstrumentMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - userDefinedInstrumentEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t userDefinedInstrumentEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD char userDefinedInstrument() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 84, sizeof(char)); - return (val); - } + SBE_NODISCARD char userDefinedInstrument() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 84, sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread56 & - userDefinedInstrument(const char value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 84, &val, sizeof(char)); - return *this; - } + MDInstrumentDefinitionSpread56 &userDefinedInstrument(const char value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 84, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char * - MatchAlgorithmMetaAttribute(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 *MatchAlgorithmMetaAttribute(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 matchAlgorithmId() SBE_NOEXCEPT { - return 1142; - } + static SBE_CONSTEXPR std::uint16_t matchAlgorithmId() SBE_NOEXCEPT + { + return 1142; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchAlgorithmSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchAlgorithmSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchAlgorithmInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchAlgorithmInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchAlgorithmSinceVersion(); + return m_actingVersion >= matchAlgorithmSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchAlgorithmEncodingOffset() SBE_NOEXCEPT { - return 85; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchAlgorithmEncodingOffset() SBE_NOEXCEPT + { + return 85; + } - static SBE_CONSTEXPR char matchAlgorithmNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char matchAlgorithmNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char matchAlgorithmMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char matchAlgorithmMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char matchAlgorithmMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char matchAlgorithmMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t - matchAlgorithmEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchAlgorithmEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD char matchAlgorithm() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 85, sizeof(char)); - return (val); - } + SBE_NODISCARD char matchAlgorithm() const SBE_NOEXCEPT + { + char val; + std::memcpy(&val, m_buffer + m_offset + 85, sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread56 & - matchAlgorithm(const char value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 85, &val, sizeof(char)); - return *this; - } + MDInstrumentDefinitionSpread56 &matchAlgorithm(const char value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 85, &val, sizeof(char)); + return *this; + } - SBE_NODISCARD static const char * - MinTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MinTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t minTradeVolId() SBE_NOEXCEPT { - return 562; - } + static SBE_CONSTEXPR std::uint16_t minTradeVolId() SBE_NOEXCEPT + { + return 562; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minTradeVolSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minTradeVolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool minTradeVolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minTradeVolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minTradeVolSinceVersion(); + return m_actingVersion >= minTradeVolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minTradeVolEncodingOffset() SBE_NOEXCEPT { - return 86; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minTradeVolEncodingOffset() SBE_NOEXCEPT + { + return 86; + } - static SBE_CONSTEXPR std::uint32_t minTradeVolNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t minTradeVolNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t minTradeVolMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t minTradeVolMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t minTradeVolMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t minTradeVolMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t minTradeVolEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t minTradeVolEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t minTradeVol() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 86, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t minTradeVol() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 86, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionSpread56 & - minTradeVol(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 86, &val, sizeof(std::uint32_t)); - return *this; - } + MDInstrumentDefinitionSpread56 &minTradeVol(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 86, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char * - MaxTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MaxTradeVolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t maxTradeVolId() SBE_NOEXCEPT { - return 1140; - } + static SBE_CONSTEXPR std::uint16_t maxTradeVolId() SBE_NOEXCEPT + { + return 1140; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - maxTradeVolSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maxTradeVolSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool maxTradeVolInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool maxTradeVolInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= maxTradeVolSinceVersion(); + return m_actingVersion >= maxTradeVolSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maxTradeVolEncodingOffset() SBE_NOEXCEPT { - return 90; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maxTradeVolEncodingOffset() SBE_NOEXCEPT + { + return 90; + } - static SBE_CONSTEXPR std::uint32_t maxTradeVolNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t maxTradeVolNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t maxTradeVolMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t maxTradeVolMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t maxTradeVolMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t maxTradeVolMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t maxTradeVolEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t maxTradeVolEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t maxTradeVol() const SBE_NOEXCEPT { - std::uint32_t val; - std::memcpy(&val, m_buffer + m_offset + 90, sizeof(std::uint32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::uint32_t maxTradeVol() const SBE_NOEXCEPT + { + std::uint32_t val; + std::memcpy(&val, m_buffer + m_offset + 90, sizeof(std::uint32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionSpread56 & - maxTradeVol(const std::uint32_t value) SBE_NOEXCEPT { - std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 90, &val, sizeof(std::uint32_t)); - return *this; - } + MDInstrumentDefinitionSpread56 &maxTradeVol(const std::uint32_t value) SBE_NOEXCEPT + { + std::uint32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 90, &val, sizeof(std::uint32_t)); + return *this; + } - SBE_NODISCARD static const char *MinPriceIncrementMetaAttribute( - 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 *MinPriceIncrementMetaAttribute(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 minPriceIncrementId() SBE_NOEXCEPT { - return 969; - } + static SBE_CONSTEXPR std::uint16_t minPriceIncrementId() SBE_NOEXCEPT + { + return 969; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minPriceIncrementSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minPriceIncrementSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool minPriceIncrementInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool minPriceIncrementInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= minPriceIncrementSinceVersion(); + return m_actingVersion >= minPriceIncrementSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minPriceIncrementEncodingOffset() SBE_NOEXCEPT { - return 94; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minPriceIncrementEncodingOffset() SBE_NOEXCEPT + { + return 94; + } - private: - PRICENULL9 m_minPriceIncrement; +private: + PRICENULL9 m_minPriceIncrement; - public: - SBE_NODISCARD PRICENULL9 &minPriceIncrement() { - m_minPriceIncrement.wrap( - m_buffer, m_offset + 94, m_actingVersion, m_bufferLength); - return m_minPriceIncrement; - } +public: + SBE_NODISCARD PRICENULL9 &minPriceIncrement() + { + m_minPriceIncrement.wrap(m_buffer, m_offset + 94, m_actingVersion, m_bufferLength); + return m_minPriceIncrement; + } - SBE_NODISCARD static const char * - DisplayFactorMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "float"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *DisplayFactorMetaAttribute(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 displayFactorId() SBE_NOEXCEPT { - return 9787; - } + static SBE_CONSTEXPR std::uint16_t displayFactorId() SBE_NOEXCEPT + { + return 9787; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - displayFactorSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t displayFactorSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool displayFactorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool displayFactorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= displayFactorSinceVersion(); + return m_actingVersion >= displayFactorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - displayFactorEncodingOffset() SBE_NOEXCEPT { - return 102; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t displayFactorEncodingOffset() SBE_NOEXCEPT + { + return 102; + } - private: - Decimal9 m_displayFactor; +private: + Decimal9 m_displayFactor; - public: - SBE_NODISCARD Decimal9 &displayFactor() { - m_displayFactor.wrap( - m_buffer, m_offset + 102, m_actingVersion, m_bufferLength); - return m_displayFactor; - } +public: + SBE_NODISCARD Decimal9 &displayFactor() + { + m_displayFactor.wrap(m_buffer, m_offset + 102, m_actingVersion, m_bufferLength); + return m_displayFactor; + } - SBE_NODISCARD static const char *PriceDisplayFormatMetaAttribute( - 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 *PriceDisplayFormatMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t priceDisplayFormatId() SBE_NOEXCEPT { - return 9800; - } + static SBE_CONSTEXPR std::uint16_t priceDisplayFormatId() SBE_NOEXCEPT + { + return 9800; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceDisplayFormatSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceDisplayFormatSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool priceDisplayFormatInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool priceDisplayFormatInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= priceDisplayFormatSinceVersion(); + return m_actingVersion >= priceDisplayFormatSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceDisplayFormatEncodingOffset() SBE_NOEXCEPT { - return 110; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceDisplayFormatEncodingOffset() SBE_NOEXCEPT + { + return 110; + } - static SBE_CONSTEXPR std::uint8_t - priceDisplayFormatNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t priceDisplayFormatNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t priceDisplayFormatMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t - priceDisplayFormatEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t priceDisplayFormatEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t priceDisplayFormat() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 110, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t priceDisplayFormat() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 110, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionSpread56 & - priceDisplayFormat(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 110, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionSpread56 &priceDisplayFormat(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 110, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - PriceRatioMetaAttribute(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 *PriceRatioMetaAttribute(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 priceRatioId() SBE_NOEXCEPT { - return 5770; - } + static SBE_CONSTEXPR std::uint16_t priceRatioId() SBE_NOEXCEPT + { + return 5770; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - priceRatioSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t priceRatioSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool priceRatioInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool priceRatioInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= priceRatioSinceVersion(); + return m_actingVersion >= priceRatioSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - priceRatioEncodingOffset() SBE_NOEXCEPT { - return 111; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t priceRatioEncodingOffset() SBE_NOEXCEPT + { + return 111; + } - private: - PRICENULL9 m_priceRatio; +private: + PRICENULL9 m_priceRatio; - public: - SBE_NODISCARD PRICENULL9 &priceRatio() { - m_priceRatio.wrap( - m_buffer, m_offset + 111, m_actingVersion, m_bufferLength); - return m_priceRatio; - } +public: + SBE_NODISCARD PRICENULL9 &priceRatio() + { + m_priceRatio.wrap(m_buffer, m_offset + 111, m_actingVersion, m_bufferLength); + return m_priceRatio; + } - SBE_NODISCARD static const char * - TickRuleMetaAttribute(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 *TickRuleMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t tickRuleId() SBE_NOEXCEPT { return 6350; } + static SBE_CONSTEXPR std::uint16_t tickRuleId() SBE_NOEXCEPT + { + return 6350; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tickRuleSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tickRuleSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool tickRuleInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tickRuleInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tickRuleSinceVersion(); + return m_actingVersion >= tickRuleSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tickRuleEncodingOffset() SBE_NOEXCEPT { - return 119; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tickRuleEncodingOffset() SBE_NOEXCEPT + { + return 119; + } - static SBE_CONSTEXPR std::int8_t tickRuleNullValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t tickRuleNullValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::int8_t tickRuleMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } + static SBE_CONSTEXPR std::int8_t tickRuleMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } - static SBE_CONSTEXPR std::int8_t tickRuleMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } + static SBE_CONSTEXPR std::int8_t tickRuleMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } - static SBE_CONSTEXPR std::size_t tickRuleEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t tickRuleEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::int8_t tickRule() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 119, sizeof(std::int8_t)); - return (val); - } + SBE_NODISCARD std::int8_t tickRule() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 119, sizeof(std::int8_t)); + return (val); + } - MDInstrumentDefinitionSpread56 & - tickRule(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 119, &val, sizeof(std::int8_t)); - return *this; - } + MDInstrumentDefinitionSpread56 &tickRule(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 119, &val, sizeof(std::int8_t)); + return *this; + } - SBE_NODISCARD static const char * - UnitOfMeasureMetaAttribute(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 *UnitOfMeasureMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t unitOfMeasureId() SBE_NOEXCEPT { - return 996; - } + static SBE_CONSTEXPR std::uint16_t unitOfMeasureId() SBE_NOEXCEPT + { + return 996; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - unitOfMeasureSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t unitOfMeasureSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool unitOfMeasureInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool unitOfMeasureInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= unitOfMeasureSinceVersion(); + return m_actingVersion >= unitOfMeasureSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - unitOfMeasureEncodingOffset() SBE_NOEXCEPT { - return 120; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t unitOfMeasureEncodingOffset() SBE_NOEXCEPT + { + return 120; + } - static SBE_CONSTEXPR char unitOfMeasureNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char unitOfMeasureNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char unitOfMeasureMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char unitOfMeasureMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char unitOfMeasureMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char unitOfMeasureMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t unitOfMeasureEncodingLength() SBE_NOEXCEPT { - return 30; - } + static SBE_CONSTEXPR std::size_t unitOfMeasureEncodingLength() SBE_NOEXCEPT + { + return 30; + } - static SBE_CONSTEXPR std::uint64_t unitOfMeasureLength() SBE_NOEXCEPT { - return 30; - } + static SBE_CONSTEXPR std::uint64_t unitOfMeasureLength() SBE_NOEXCEPT + { + return 30; + } - SBE_NODISCARD const char *unitOfMeasure() const SBE_NOEXCEPT { - return m_buffer + m_offset + 120; - } + SBE_NODISCARD const char *unitOfMeasure() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 120; + } - SBE_NODISCARD char *unitOfMeasure() SBE_NOEXCEPT { - return m_buffer + m_offset + 120; - } + SBE_NODISCARD char *unitOfMeasure() SBE_NOEXCEPT + { + return m_buffer + m_offset + 120; + } - SBE_NODISCARD char unitOfMeasure(const std::uint64_t index) const { - if (index >= 30) { - throw std::runtime_error( - "index out of range for unitOfMeasure [E104]"); - } + SBE_NODISCARD char unitOfMeasure(const std::uint64_t index) const + { + if (index >= 30) + { + throw std::runtime_error("index out of range for unitOfMeasure [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 120 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 120 + (index * 1), sizeof(char)); + return (val); + } - MDInstrumentDefinitionSpread56 & - unitOfMeasure(const std::uint64_t index, const char value) { - if (index >= 30) { - throw std::runtime_error( - "index out of range for unitOfMeasure [E105]"); - } + MDInstrumentDefinitionSpread56 &unitOfMeasure(const std::uint64_t index, const char value) + { + if (index >= 30) + { + throw std::runtime_error("index out of range for unitOfMeasure [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 120 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 120 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getUnitOfMeasure(char *const dst, const std::uint64_t length) const { - if (length > 30) { - throw std::runtime_error( - "length too large for getUnitOfMeasure [E106]"); - } + std::uint64_t getUnitOfMeasure(char *const dst, const std::uint64_t length) const + { + if (length > 30) + { + throw std::runtime_error("length too large for getUnitOfMeasure [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 120, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 120, sizeof(char) * static_cast(length)); + return length; + } - MDInstrumentDefinitionSpread56 & - putUnitOfMeasure(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 120, src, sizeof(char) * 30); - return *this; - } + MDInstrumentDefinitionSpread56 &putUnitOfMeasure(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 120, src, sizeof(char) * 30); + return *this; + } - std::string getUnitOfMeasureAsString() const { - const char *buffer = m_buffer + m_offset + 120; - size_t length = 0; + SBE_NODISCARD std::string getUnitOfMeasureAsString() const + { + const char *buffer = m_buffer + m_offset + 120; + 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 getUnitOfMeasureAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getUnitOfMeasureAsString(); + std::string getUnitOfMeasureAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getUnitOfMeasureAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getUnitOfMeasureAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 120; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getUnitOfMeasureAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 120; + 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 - MDInstrumentDefinitionSpread56 & - putUnitOfMeasure(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 30) { - throw std::runtime_error( - "string too large for putUnitOfMeasure [E106]"); - } + #if __cplusplus >= 201703L + MDInstrumentDefinitionSpread56 &putUnitOfMeasure(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 30) + { + throw std::runtime_error("string too large for putUnitOfMeasure [E106]"); + } - std::memcpy(m_buffer + m_offset + 120, str.data(), srcLength); - for (size_t start = srcLength; start < 30; ++start) { - m_buffer[m_offset + 120 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 120, str.data(), srcLength); + for (size_t start = srcLength; start < 30; ++start) + { + m_buffer[m_offset + 120 + start] = 0; + } - return *this; - } -#else - MDInstrumentDefinitionSpread56 &putUnitOfMeasure(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 30) { - throw std::runtime_error( - "string too large for putUnitOfMeasure [E106]"); - } + return *this; + } + #else + MDInstrumentDefinitionSpread56 &putUnitOfMeasure(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 30) + { + throw std::runtime_error("string too large for putUnitOfMeasure [E106]"); + } - std::memcpy(m_buffer + m_offset + 120, str.c_str(), srcLength); - for (size_t start = srcLength; start < 30; ++start) { - m_buffer[m_offset + 120 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 120, str.c_str(), srcLength); + for (size_t start = srcLength; start < 30; ++start) + { + m_buffer[m_offset + 120 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *TradingReferencePriceMetaAttribute( - 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 *TradingReferencePriceMetaAttribute(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 tradingReferencePriceId() SBE_NOEXCEPT { - return 1150; - } + static SBE_CONSTEXPR std::uint16_t tradingReferencePriceId() SBE_NOEXCEPT + { + return 1150; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingReferencePriceSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingReferencePriceSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool tradingReferencePriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tradingReferencePriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tradingReferencePriceSinceVersion(); + return m_actingVersion >= tradingReferencePriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingReferencePriceEncodingOffset() SBE_NOEXCEPT { - return 150; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingReferencePriceEncodingOffset() SBE_NOEXCEPT + { + return 150; + } - private: - PRICENULL9 m_tradingReferencePrice; +private: + PRICENULL9 m_tradingReferencePrice; - public: - SBE_NODISCARD PRICENULL9 &tradingReferencePrice() { - m_tradingReferencePrice.wrap( - m_buffer, m_offset + 150, m_actingVersion, m_bufferLength); - return m_tradingReferencePrice; - } +public: + SBE_NODISCARD PRICENULL9 &tradingReferencePrice() + { + m_tradingReferencePrice.wrap(m_buffer, m_offset + 150, m_actingVersion, m_bufferLength); + return m_tradingReferencePrice; + } - SBE_NODISCARD static const char * - SettlPriceTypeMetaAttribute(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 *SettlPriceTypeMetaAttribute(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 settlPriceTypeId() SBE_NOEXCEPT { - return 731; - } + static SBE_CONSTEXPR std::uint16_t settlPriceTypeId() SBE_NOEXCEPT + { + return 731; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - settlPriceTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t settlPriceTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= settlPriceTypeSinceVersion(); + return m_actingVersion >= settlPriceTypeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingOffset() SBE_NOEXCEPT { - return 158; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingOffset() SBE_NOEXCEPT + { + return 158; + } - private: - SettlPriceType m_settlPriceType; +private: + SettlPriceType m_settlPriceType; - public: - SBE_NODISCARD SettlPriceType &settlPriceType() { - m_settlPriceType.wrap( - m_buffer, m_offset + 158, m_actingVersion, m_bufferLength); - return m_settlPriceType; - } +public: + SBE_NODISCARD SettlPriceType &settlPriceType() + { + m_settlPriceType.wrap(m_buffer, m_offset + 158, m_actingVersion, m_bufferLength); + return m_settlPriceType; + } - static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char *OpenInterestQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *OpenInterestQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t openInterestQtyId() SBE_NOEXCEPT { - return 5792; - } + static SBE_CONSTEXPR std::uint16_t openInterestQtyId() SBE_NOEXCEPT + { + return 5792; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - openInterestQtySinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t openInterestQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool openInterestQtyInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool openInterestQtyInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= openInterestQtySinceVersion(); + return m_actingVersion >= openInterestQtySinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - openInterestQtyEncodingOffset() SBE_NOEXCEPT { - return 159; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t openInterestQtyEncodingOffset() SBE_NOEXCEPT + { + return 159; + } - static SBE_CONSTEXPR std::int32_t openInterestQtyNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t openInterestQtyNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t openInterestQtyMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t openInterestQtyMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t openInterestQtyMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t openInterestQtyMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t - openInterestQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t openInterestQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t openInterestQty() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 159, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t openInterestQty() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 159, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionSpread56 & - openInterestQty(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 159, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionSpread56 &openInterestQty(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 159, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - ClearedVolumeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } + SBE_NODISCARD static const char *ClearedVolumeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t clearedVolumeId() SBE_NOEXCEPT { - return 5791; - } + static SBE_CONSTEXPR std::uint16_t clearedVolumeId() SBE_NOEXCEPT + { + return 5791; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - clearedVolumeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t clearedVolumeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool clearedVolumeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool clearedVolumeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= clearedVolumeSinceVersion(); + return m_actingVersion >= clearedVolumeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - clearedVolumeEncodingOffset() SBE_NOEXCEPT { - return 163; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t clearedVolumeEncodingOffset() SBE_NOEXCEPT + { + return 163; + } - static SBE_CONSTEXPR std::int32_t clearedVolumeNullValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t clearedVolumeNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::int32_t clearedVolumeMinValue() SBE_NOEXCEPT { - return -2147483647; - } + static SBE_CONSTEXPR std::int32_t clearedVolumeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } - static SBE_CONSTEXPR std::int32_t clearedVolumeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } + static SBE_CONSTEXPR std::int32_t clearedVolumeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } - static SBE_CONSTEXPR std::size_t clearedVolumeEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t clearedVolumeEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::int32_t clearedVolume() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 163, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } + SBE_NODISCARD std::int32_t clearedVolume() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 163, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - MDInstrumentDefinitionSpread56 & - clearedVolume(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 163, &val, sizeof(std::int32_t)); - return *this; - } + MDInstrumentDefinitionSpread56 &clearedVolume(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 163, &val, sizeof(std::int32_t)); + return *this; + } - SBE_NODISCARD static const char * - HighLimitPriceMetaAttribute(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 *HighLimitPriceMetaAttribute(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 highLimitPriceId() SBE_NOEXCEPT { - return 1149; - } + static SBE_CONSTEXPR std::uint16_t highLimitPriceId() SBE_NOEXCEPT + { + return 1149; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - highLimitPriceSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t highLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= highLimitPriceSinceVersion(); + return m_actingVersion >= highLimitPriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - highLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 167; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t highLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 167; + } - private: - PRICENULL9 m_highLimitPrice; +private: + PRICENULL9 m_highLimitPrice; - public: - SBE_NODISCARD PRICENULL9 &highLimitPrice() { - m_highLimitPrice.wrap( - m_buffer, m_offset + 167, m_actingVersion, m_bufferLength); - return m_highLimitPrice; - } +public: + SBE_NODISCARD PRICENULL9 &highLimitPrice() + { + m_highLimitPrice.wrap(m_buffer, m_offset + 167, m_actingVersion, m_bufferLength); + return m_highLimitPrice; + } - SBE_NODISCARD static const char * - LowLimitPriceMetaAttribute(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 *LowLimitPriceMetaAttribute(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 lowLimitPriceId() SBE_NOEXCEPT { - return 1148; - } + static SBE_CONSTEXPR std::uint16_t lowLimitPriceId() SBE_NOEXCEPT + { + return 1148; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lowLimitPriceSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lowLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lowLimitPriceSinceVersion(); + return m_actingVersion >= lowLimitPriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lowLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 175; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lowLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 175; + } - private: - PRICENULL9 m_lowLimitPrice; +private: + PRICENULL9 m_lowLimitPrice; - public: - SBE_NODISCARD PRICENULL9 &lowLimitPrice() { - m_lowLimitPrice.wrap( - m_buffer, m_offset + 175, m_actingVersion, m_bufferLength); - return m_lowLimitPrice; - } +public: + SBE_NODISCARD PRICENULL9 &lowLimitPrice() + { + m_lowLimitPrice.wrap(m_buffer, m_offset + 175, m_actingVersion, m_bufferLength); + return m_lowLimitPrice; + } - SBE_NODISCARD static const char *MaxPriceVariationMetaAttribute( - 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 *MaxPriceVariationMetaAttribute(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 maxPriceVariationId() SBE_NOEXCEPT { - return 1143; - } + static SBE_CONSTEXPR std::uint16_t maxPriceVariationId() SBE_NOEXCEPT + { + return 1143; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - maxPriceVariationSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maxPriceVariationSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool maxPriceVariationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool maxPriceVariationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= maxPriceVariationSinceVersion(); + return m_actingVersion >= maxPriceVariationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maxPriceVariationEncodingOffset() SBE_NOEXCEPT { - return 183; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maxPriceVariationEncodingOffset() SBE_NOEXCEPT + { + return 183; + } - private: - PRICENULL9 m_maxPriceVariation; +private: + PRICENULL9 m_maxPriceVariation; - public: - SBE_NODISCARD PRICENULL9 &maxPriceVariation() { - m_maxPriceVariation.wrap( - m_buffer, m_offset + 183, m_actingVersion, m_bufferLength); - return m_maxPriceVariation; - } +public: + SBE_NODISCARD PRICENULL9 &maxPriceVariation() + { + m_maxPriceVariation.wrap(m_buffer, m_offset + 183, m_actingVersion, m_bufferLength); + return m_maxPriceVariation; + } - SBE_NODISCARD static const char * - MainFractionMetaAttribute(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 *MainFractionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mainFractionId() SBE_NOEXCEPT { - return 37702; - } + static SBE_CONSTEXPR std::uint16_t mainFractionId() SBE_NOEXCEPT + { + return 37702; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mainFractionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mainFractionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mainFractionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mainFractionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mainFractionSinceVersion(); + return m_actingVersion >= mainFractionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mainFractionEncodingOffset() SBE_NOEXCEPT { - return 191; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mainFractionEncodingOffset() SBE_NOEXCEPT + { + return 191; + } - static SBE_CONSTEXPR std::uint8_t mainFractionNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t mainFractionNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t mainFractionMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t mainFractionMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t mainFractionMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t mainFractionMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t mainFractionEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t mainFractionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t mainFraction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 191, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t mainFraction() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 191, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionSpread56 & - mainFraction(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 191, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionSpread56 &mainFraction(const std::uint8_t 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 * - SubFractionMetaAttribute(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 *SubFractionMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t subFractionId() SBE_NOEXCEPT { - return 37703; - } + static SBE_CONSTEXPR std::uint16_t subFractionId() SBE_NOEXCEPT + { + return 37703; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - subFractionSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t subFractionSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool subFractionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool subFractionInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= subFractionSinceVersion(); + return m_actingVersion >= subFractionSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - subFractionEncodingOffset() SBE_NOEXCEPT { - return 192; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t subFractionEncodingOffset() SBE_NOEXCEPT + { + return 192; + } - static SBE_CONSTEXPR std::uint8_t subFractionNullValue() SBE_NOEXCEPT { - return (std::uint8_t)255; - } + static SBE_CONSTEXPR std::uint8_t subFractionNullValue() SBE_NOEXCEPT + { + return static_cast(255); + } - static SBE_CONSTEXPR std::uint8_t subFractionMinValue() SBE_NOEXCEPT { - return (std::uint8_t)0; - } + static SBE_CONSTEXPR std::uint8_t subFractionMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint8_t subFractionMaxValue() SBE_NOEXCEPT { - return (std::uint8_t)254; - } + static SBE_CONSTEXPR std::uint8_t subFractionMaxValue() SBE_NOEXCEPT + { + return static_cast(254); + } - static SBE_CONSTEXPR std::size_t subFractionEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t subFractionEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD std::uint8_t subFraction() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 192, sizeof(std::uint8_t)); - return (val); - } + SBE_NODISCARD std::uint8_t subFraction() const SBE_NOEXCEPT + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 192, sizeof(std::uint8_t)); + return (val); + } - MDInstrumentDefinitionSpread56 & - subFraction(const std::uint8_t value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 192, &val, sizeof(std::uint8_t)); - return *this; - } + MDInstrumentDefinitionSpread56 &subFraction(const std::uint8_t value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 192, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char *TradingReferenceDateMetaAttribute( - 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 *TradingReferenceDateMetaAttribute(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 tradingReferenceDateId() SBE_NOEXCEPT { - return 5796; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateId() SBE_NOEXCEPT + { + return 5796; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingReferenceDateSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingReferenceDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tradingReferenceDateSinceVersion(); + return m_actingVersion >= tradingReferenceDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingOffset() SBE_NOEXCEPT { - return 193; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingOffset() SBE_NOEXCEPT + { + return 193; + } - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } - SBE_NODISCARD std::uint16_t tradingReferenceDate() 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 tradingReferenceDate() 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); + } - MDInstrumentDefinitionSpread56 & - tradingReferenceDate(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; - } + MDInstrumentDefinitionSpread56 &tradingReferenceDate(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; + } - class NoEvents { + class NoEvents + { 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 NoEvents &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(static_cast(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 *EventTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t eventTypeId() SBE_NOEXCEPT + { + return 865; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t eventTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool eventTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= eventTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t eventTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t eventTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD EventType::Value eventType() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint8_t)); + return EventType::get((val)); + } + + NoEvents &eventType(const EventType::Value 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 *EventTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t eventTimeId() SBE_NOEXCEPT + { + return 1145; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t eventTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool eventTimeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= eventTimeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t eventTimeEncodingOffset() SBE_NOEXCEPT + { + return 1; + } + + static SBE_CONSTEXPR std::uint64_t eventTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } + + static SBE_CONSTEXPR std::uint64_t eventTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t eventTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t eventTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t eventTime() const SBE_NOEXCEPT + { + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoEvents &eventTime(const std::uint64_t value) SBE_NOEXCEPT + { + std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); + std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint64_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoEvents writer) + { + builder << '{'; + builder << R"("EventType": )"; + builder << '"' << writer.eventType() << '"'; + + builder << ", "; + builder << R"("EventTime": )"; + builder << +writer.eventTime(); + + 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: + NoEvents m_noEvents; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 9; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoEventsId() SBE_NOEXCEPT + { + return 864; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoEvents &noEvents() + { + m_noEvents.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noEvents; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoEvents &noEventsCount(const std::uint8_t count) + { + m_noEvents.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noEvents; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noEventsSinceVersion() 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 NoEvents &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 * - EventTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t eventTypeId() SBE_NOEXCEPT { - return 865; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - eventTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool eventTypeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noEventsInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= eventTypeSinceVersion(); + return m_actingVersion >= noEventsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - eventTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - eventTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD EventType::Value eventType() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::uint8_t)); - return EventType::get((val)); - } - - NoEvents &eventType(const EventType::Value 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 * - EventTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t eventTimeId() SBE_NOEXCEPT { - return 1145; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - eventTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool eventTimeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= eventTimeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - eventTimeEncodingOffset() SBE_NOEXCEPT { - return 1; - } - - static SBE_CONSTEXPR std::uint64_t eventTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } - - static SBE_CONSTEXPR std::uint64_t eventTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t eventTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t eventTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t eventTime() const SBE_NOEXCEPT { - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 1, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoEvents &eventTime(const std::uint64_t value) SBE_NOEXCEPT { - std::uint64_t val = SBE_LITTLE_ENDIAN_ENCODE_64(value); - std::memcpy(m_buffer + m_offset + 1, &val, sizeof(std::uint64_t)); - return *this; - } - - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoEvents writer) { - builder << '{'; - builder << R"("EventType": )"; - builder << '"' << writer.eventType() << '"'; - - builder << ", "; - builder << R"("EventTime": )"; - builder << +writer.eventTime(); - - builder << '}'; - - return builder; - } - }; - - private: - NoEvents m_noEvents; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoEventsId() SBE_NOEXCEPT { - return 864; - } - - SBE_NODISCARD inline NoEvents &noEvents() { - m_noEvents.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noEvents; - } - - NoEvents &noEventsCount(const std::uint8_t count) { - m_noEvents.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noEvents; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noEventsSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noEventsInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noEventsSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoMDFeedTypes { + class NoMDFeedTypes + { 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)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 { 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 < m_count; - } - - inline NoMDFeedTypes &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 * - MDFeedTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDFeedTypeId() SBE_NOEXCEPT { - return 1022; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDFeedTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDFeedTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDFeedTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDFeedTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR char mDFeedTypeNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char mDFeedTypeMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char mDFeedTypeMaxValue() SBE_NOEXCEPT { - return (char)126; - } - - static SBE_CONSTEXPR std::size_t mDFeedTypeEncodingLength() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::uint64_t mDFeedTypeLength() SBE_NOEXCEPT { - return 3; - } - - SBE_NODISCARD const char *mDFeedType() const SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char *mDFeedType() SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - SBE_NODISCARD char mDFeedType(const std::uint64_t index) const { - if (index >= 3) { - throw std::runtime_error( - "index out of range for mDFeedType [E104]"); - } - - char val; - std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); - return (val); - } - - NoMDFeedTypes &mDFeedType(const std::uint64_t index, const char value) { - if (index >= 3) { - throw std::runtime_error( - "index out of range for mDFeedType [E105]"); - } - - char val = (value); - std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); - return *this; - } - - std::uint64_t - getMDFeedType(char *const dst, const std::uint64_t length) const { - if (length > 3) { - throw std::runtime_error( - "length too large for getMDFeedType [E106]"); - } - - std::memcpy( - dst, m_buffer + m_offset + 0, - sizeof(char) * static_cast(length)); - return length; - } - - NoMDFeedTypes &putMDFeedType(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 3); - return *this; - } - - NoMDFeedTypes & - putMDFeedType(const char value0, const char value1, const char value2) - SBE_NOEXCEPT { - char val0 = (value0); - std::memcpy(m_buffer + m_offset + 0, &val0, sizeof(char)); - char val1 = (value1); - std::memcpy(m_buffer + m_offset + 1, &val1, sizeof(char)); - char val2 = (value2); - std::memcpy(m_buffer + m_offset + 2, &val2, sizeof(char)); - - return *this; - } - - std::string getMDFeedTypeAsString() const { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 3 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); - - return result; - } - - std::string getMDFeedTypeAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getMDFeedTypeAsString(); - - 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; - } + 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 - std::string_view getMDFeedTypeAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 0; - size_t length = 0; - - for (; length < 3 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); - - return result; - } -#endif - -#if __cplusplus >= 201703L - NoMDFeedTypes &putMDFeedType(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putMDFeedType [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#else - NoMDFeedTypes &putMDFeedType(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 3) { - throw std::runtime_error( - "string too large for putMDFeedType [E106]"); - } - - std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); - for (size_t start = srcLength; start < 3; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#endif - - SBE_NODISCARD static const char * - MarketDepthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t marketDepthId() SBE_NOEXCEPT { - return 264; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - marketDepthSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool marketDepthInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= marketDepthSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - marketDepthEncodingOffset() SBE_NOEXCEPT { - return 3; - } - - static SBE_CONSTEXPR std::int8_t marketDepthNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t marketDepthMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t marketDepthMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t - marketDepthEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::int8_t marketDepth() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 3, sizeof(std::int8_t)); - return (val); - } - - NoMDFeedTypes &marketDepth(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 3, &val, sizeof(std::int8_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDFeedTypes writer) { - builder << '{'; - builder << R"("MDFeedType": )"; - builder << '"' << writer.getMDFeedTypeAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("MarketDepth": )"; - builder << +writer.marketDepth(); - - builder << '}'; - - return builder; - } - }; - - private: - NoMDFeedTypes m_noMDFeedTypes; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDFeedTypesId() SBE_NOEXCEPT { - return 1141; - } - - SBE_NODISCARD inline NoMDFeedTypes &noMDFeedTypes() { - m_noMDFeedTypes.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDFeedTypes; - } - - NoMDFeedTypes &noMDFeedTypesCount(const std::uint8_t count) { - m_noMDFeedTypes.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDFeedTypes; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDFeedTypesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDFeedTypesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDFeedTypesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoInstAttrib { - 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)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 { 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 < m_count; - } - - inline NoInstAttrib &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 *InstAttribTypeMetaAttribute( - 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 instAttribTypeId() SBE_NOEXCEPT { - return 871; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - instAttribTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool instAttribTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= instAttribTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - instAttribTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int8_t instAttribTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t instAttribTypeMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t instAttribTypeMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t - instAttribTypeEncodingLength() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::int8_t - instAttribType() SBE_NOEXCEPT { - return (std::int8_t)24; - } - - SBE_NODISCARD static const char *InstAttribValueMetaAttribute( - 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 instAttribValueId() SBE_NOEXCEPT { - return 872; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - instAttribValueSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool instAttribValueInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= instAttribValueSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - instAttribValueEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - private: - InstAttribValue m_instAttribValue; - - public: - SBE_NODISCARD InstAttribValue &instAttribValue() { - m_instAttribValue.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_instAttribValue; - } - - static SBE_CONSTEXPR std::size_t - instAttribValueEncodingLength() SBE_NOEXCEPT { - return 4; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoInstAttrib writer) { - builder << '{'; - builder << R"("InstAttribValue": )"; - builder << writer.instAttribValue(); - - builder << '}'; - - return builder; - } - }; - - private: - NoInstAttrib m_noInstAttrib; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoInstAttribId() SBE_NOEXCEPT { - return 870; - } - - SBE_NODISCARD inline NoInstAttrib &noInstAttrib() { - m_noInstAttrib.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noInstAttrib; - } - - NoInstAttrib &noInstAttribCount(const std::uint8_t count) { - m_noInstAttrib.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noInstAttrib; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noInstAttribSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noInstAttribInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noInstAttribSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - class NoLotTypeRules { - 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)5); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 5; - 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 5; - } - - 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 < m_count; - } - - inline NoLotTypeRules &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 * - LotTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t lotTypeId() SBE_NOEXCEPT { - return 1093; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lotTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool lotTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= lotTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lotTypeEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - static SBE_CONSTEXPR std::int8_t lotTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t lotTypeMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t lotTypeMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t lotTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::int8_t lotType() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int8_t)); - return (val); - } - - NoLotTypeRules &lotType(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int8_t)); - return *this; - } - - SBE_NODISCARD static const char * - MinLotSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t minLotSizeId() SBE_NOEXCEPT { - return 1231; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - minLotSizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool minLotSizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= minLotSizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - minLotSizeEncodingOffset() SBE_NOEXCEPT { - return 1; - } - - private: - DecimalQty m_minLotSize; - - public: - SBE_NODISCARD DecimalQty &minLotSize() { - m_minLotSize.wrap( - m_buffer, m_offset + 1, m_actingVersion, m_bufferLength); - return m_minLotSize; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoLotTypeRules writer) { - builder << '{'; - builder << R"("LotType": )"; - builder << +writer.lotType(); - - builder << ", "; - builder << R"("MinLotSize": )"; - builder << writer.minLotSize(); - - builder << '}'; - - return builder; - } - }; - - private: - NoLotTypeRules m_noLotTypeRules; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoLotTypeRulesId() SBE_NOEXCEPT { - return 1234; - } - - SBE_NODISCARD inline NoLotTypeRules &noLotTypeRules() { - m_noLotTypeRules.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLotTypeRules; - } - - NoLotTypeRules &noLotTypeRulesCount(const std::uint8_t count) { - m_noLotTypeRules.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLotTypeRules; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noLotTypeRulesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noLotTypeRulesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noLotTypeRulesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - 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)18); - dimensions.numInGroup((std::uint8_t)count); - m_index = 0; - m_count = count; - m_blockLength = 18; - 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 18; - } - - 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 < 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 *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 0; - } - - 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 + 0, 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 + 0, &val, sizeof(std::int32_t)); - return *this; - } - - 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 4; - } - - static SBE_CONSTEXPR char legSecurityIDSourceNullValue() SBE_NOEXCEPT { - return (char)0; - } - - static SBE_CONSTEXPR char legSecurityIDSourceMinValue() SBE_NOEXCEPT { - return (char)32; - } - - static SBE_CONSTEXPR char legSecurityIDSourceMaxValue() SBE_NOEXCEPT { - return (char)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}; - - return (const char *)legSecurityIDSourceValues; - } - - SBE_NODISCARD char legSecurityIDSource(const std::uint64_t index) const { - static const std::uint8_t legSecurityIDSourceValues[] = {56}; - - 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 (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; - } + #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; + } + + 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; + } - return oss.str(); - } + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - 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 inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - static SBE_CONSTEXPR std::uint16_t legSideId() SBE_NOEXCEPT { - return 624; - } + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legSideSinceVersion() SBE_NOEXCEPT { - return 0; - } + inline NoMDFeedTypes &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 bool legSideInActingVersion() SBE_NOEXCEPT { + 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(static_cast(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 *MDFeedTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDFeedTypeId() SBE_NOEXCEPT + { + return 1022; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDFeedTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDFeedTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDFeedTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDFeedTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR char mDFeedTypeNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char mDFeedTypeMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char mDFeedTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } + + static SBE_CONSTEXPR std::size_t mDFeedTypeEncodingLength() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t mDFeedTypeLength() SBE_NOEXCEPT + { + return 3; + } + + SBE_NODISCARD const char *mDFeedType() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } + + SBE_NODISCARD char *mDFeedType() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } + + SBE_NODISCARD char mDFeedType(const std::uint64_t index) const + { + if (index >= 3) + { + throw std::runtime_error("index out of range for mDFeedType [E104]"); + } + + char val; + std::memcpy(&val, m_buffer + m_offset + 0 + (index * 1), sizeof(char)); + return (val); + } + + NoMDFeedTypes &mDFeedType(const std::uint64_t index, const char value) + { + if (index >= 3) + { + throw std::runtime_error("index out of range for mDFeedType [E105]"); + } + + char val = (value); + std::memcpy(m_buffer + m_offset + 0 + (index * 1), &val, sizeof(char)); + return *this; + } + + std::uint64_t getMDFeedType(char *const dst, const std::uint64_t length) const + { + if (length > 3) + { + throw std::runtime_error("length too large for getMDFeedType [E106]"); + } + + std::memcpy(dst, m_buffer + m_offset + 0, sizeof(char) * static_cast(length)); + return length; + } + + NoMDFeedTypes &putMDFeedType(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 3); + return *this; + } + + NoMDFeedTypes &putMDFeedType( + const char value0, + const char value1, + const char value2) SBE_NOEXCEPT + { + char val0 = (value0); + std::memcpy(m_buffer + m_offset + 0, &val0, sizeof(char)); + char val1 = (value1); + std::memcpy(m_buffer + m_offset + 1, &val1, sizeof(char)); + char val2 = (value2); + std::memcpy(m_buffer + m_offset + 2, &val2, sizeof(char)); + + return *this; + } + + SBE_NODISCARD std::string getMDFeedTypeAsString() const + { + const char *buffer = m_buffer + m_offset + 0; + size_t length = 0; + + for (; length < 3 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); + + return result; + } + + std::string getMDFeedTypeAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getMDFeedTypeAsString(); + + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; + + 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 getMDFeedTypeAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 0; + size_t length = 0; + + for (; length < 3 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoMDFeedTypes &putMDFeedType(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putMDFeedType [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.data(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #else + NoMDFeedTypes &putMDFeedType(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 3) + { + throw std::runtime_error("string too large for putMDFeedType [E106]"); + } + + std::memcpy(m_buffer + m_offset + 0, str.c_str(), srcLength); + for (size_t start = srcLength; start < 3; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #endif + + SBE_NODISCARD static const char *MarketDepthMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t marketDepthId() SBE_NOEXCEPT + { + return 264; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t marketDepthSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool marketDepthInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= marketDepthSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t marketDepthEncodingOffset() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::int8_t marketDepthNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t marketDepthMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t marketDepthMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t marketDepthEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::int8_t marketDepth() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 3, sizeof(std::int8_t)); + return (val); + } + + NoMDFeedTypes &marketDepth(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 3, &val, sizeof(std::int8_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDFeedTypes writer) + { + builder << '{'; + builder << R"("MDFeedType": )"; + builder << '"' << + writer.getMDFeedTypeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("MarketDepth": )"; + builder << +writer.marketDepth(); + + 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: + NoMDFeedTypes m_noMDFeedTypes; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDFeedTypesId() SBE_NOEXCEPT + { + return 1141; + } + + SBE_NODISCARD inline NoMDFeedTypes &noMDFeedTypes() + { + m_noMDFeedTypes.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDFeedTypes; + } + + NoMDFeedTypes &noMDFeedTypesCount(const std::uint8_t count) + { + m_noMDFeedTypes.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDFeedTypes; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDFeedTypesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noMDFeedTypesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= legSideSinceVersion(); + return m_actingVersion >= noMDFeedTypesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legSideEncodingOffset() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legSideEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD LegSide::Value legSide() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint8_t)); - return LegSide::get((val)); - } - - NoLegs &legSide(const LegSide::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 4, &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 "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - 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 5; - } - - static SBE_CONSTEXPR std::int8_t legRatioQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t legRatioQtyMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t legRatioQtyMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t - legRatioQtyEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::int8_t legRatioQty() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 5, sizeof(std::int8_t)); - return (val); - } - - NoLegs &legRatioQty(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 5, &val, sizeof(std::int8_t)); - return *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 9; - } - - 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 6; - } + } + class NoInstAttrib + { 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 + 6, 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 *LegOptionDeltaMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - 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(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; + } - static SBE_CONSTEXPR std::uint16_t legOptionDeltaId() SBE_NOEXCEPT { - return 1017; - } + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - legOptionDeltaSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 4; + } - 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 std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - legOptionDeltaEncodingOffset() SBE_NOEXCEPT { - return 14; - } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 NoInstAttrib &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(static_cast(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 *InstAttribTypeMetaAttribute(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 instAttribTypeId() SBE_NOEXCEPT + { + return 871; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t instAttribTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool instAttribTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= instAttribTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t instAttribTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + + static SBE_CONSTEXPR std::int8_t instAttribTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t instAttribTypeMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t instAttribTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t instAttribTypeEncodingLength() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::int8_t instAttribType() SBE_NOEXCEPT + { + return static_cast(24); + } + + SBE_NODISCARD static const char *InstAttribValueMetaAttribute(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 instAttribValueId() SBE_NOEXCEPT + { + return 872; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t instAttribValueSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool instAttribValueInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= instAttribValueSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t instAttribValueEncodingOffset() SBE_NOEXCEPT + { + return 0; + } private: - DecimalQty m_legOptionDelta; + InstAttribValue m_instAttribValue; public: - SBE_NODISCARD DecimalQty &legOptionDelta() { - m_legOptionDelta.wrap( - m_buffer, m_offset + 14, m_actingVersion, m_bufferLength); - return m_legOptionDelta; - } + SBE_NODISCARD InstAttribValue &instAttribValue() + { + m_instAttribValue.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_instAttribValue; + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, NoLegs writer) { - builder << '{'; - builder << R"("LegSecurityID": )"; - builder << +writer.legSecurityID(); + static SBE_CONSTEXPR std::size_t instAttribValueEncodingLength() SBE_NOEXCEPT + { + return 4; + } - builder << ", "; - builder << R"("LegSide": )"; - builder << '"' << writer.legSide() << '"'; + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoInstAttrib writer) + { + builder << '{'; + builder << R"("InstAttribValue": )"; + builder << writer.instAttribValue(); - builder << ", "; - builder << R"("LegRatioQty": )"; - builder << +writer.legRatioQty(); + builder << '}'; - builder << ", "; - builder << R"("LegPrice": )"; - builder << writer.legPrice(); + return builder; + } - builder << ", "; - builder << R"("LegOptionDelta": )"; - builder << writer.legOptionDelta(); + void skip() + { + } - builder << '}'; + SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT + { + return true; + } - return builder; - } - }; + 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(); - private: - NoLegs m_noLegs; + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif + } + }; - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoLegsId() SBE_NOEXCEPT { - return 555; - } +private: + NoInstAttrib m_noInstAttrib; - SBE_NODISCARD inline NoLegs &noLegs() { - m_noLegs.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLegs; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoInstAttribId() SBE_NOEXCEPT + { + return 870; + } - NoLegs &noLegsCount(const std::uint8_t count) { - m_noLegs.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noLegs; - } + SBE_NODISCARD inline NoInstAttrib &noInstAttrib() + { + m_noInstAttrib.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noInstAttrib; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noLegsSinceVersion() SBE_NOEXCEPT { - return 0; - } + NoInstAttrib &noInstAttribCount(const std::uint8_t count) + { + m_noInstAttrib.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noInstAttrib; + } - SBE_NODISCARD bool noLegsInActingVersion() const SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noInstAttribSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noInstAttribInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noLegsSinceVersion(); + return m_actingVersion >= noInstAttribSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - MDInstrumentDefinitionSpread56 _writer) { - MDInstrumentDefinitionSpread56 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "MDInstrumentDefinitionSpread56", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; + class NoLotTypeRules + { + 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"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); + SBE_NODISCARD std::uint64_t *sbePositionPtr() SBE_NOEXCEPT + { + return m_positionPtr; + } - builder << ", "; - builder << R"("TotNumReports": )"; - builder << +writer.totNumReports(); + 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"("SecurityUpdateAction": )"; - builder << '"' << writer.securityUpdateAction() << '"'; + 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(5)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 5; + m_actingVersion = actingVersion; + m_initialPosition = *pos; + m_positionPtr = pos; + *m_positionPtr = *m_positionPtr + 3; + } - builder << ", "; - builder << R"("LastUpdateTime": )"; - builder << +writer.lastUpdateTime(); + static SBE_CONSTEXPR std::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } - builder << ", "; - builder << R"("MDSecurityTradingStatus": )"; - builder << '"' << writer.mDSecurityTradingStatus() << '"'; + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 5; + } - builder << ", "; - builder << R"("ApplID": )"; - builder << +writer.applID(); + SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT + { + return *m_positionPtr; + } - builder << ", "; - builder << R"("MarketSegmentID": )"; - builder << +writer.marketSegmentID(); + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(const std::uint64_t position) + { + if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) + { + throw std::runtime_error("buffer too short [E100]"); + } + return position; + } - builder << ", "; - builder << R"("UnderlyingProduct": )"; - builder << +writer.underlyingProduct(); + void sbePosition(const std::uint64_t position) + { + *m_positionPtr = sbeCheckPosition(position); + } - builder << ", "; - builder << R"("SecurityExchange": )"; - builder << '"' << writer.getSecurityExchangeAsJsonEscapedString().c_str() - << '"'; + SBE_NODISCARD inline std::uint64_t count() const SBE_NOEXCEPT + { + return m_count; + } - builder << ", "; - builder << R"("SecurityGroup": )"; - builder << '"' << writer.getSecurityGroupAsJsonEscapedString().c_str() - << '"'; + SBE_NODISCARD inline bool hasNext() const SBE_NOEXCEPT + { + return m_index < m_count; + } - builder << ", "; - builder << R"("Asset": )"; - builder << '"' << writer.getAssetAsJsonEscapedString().c_str() << '"'; + inline NoLotTypeRules &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; - builder << ", "; - builder << R"("Symbol": )"; - builder << '"' << writer.getSymbolAsJsonEscapedString().c_str() << '"'; + return *this; + } - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + inline std::uint64_t resetCountToIndex() SBE_NOEXCEPT + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(m_count)); + return m_count; + } - builder << ", "; - builder << R"("SecurityType": )"; - builder << '"' << writer.getSecurityTypeAsJsonEscapedString().c_str() - << '"'; + #if __cplusplus < 201103L + template inline void forEach(Func& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - builder << ", "; - builder << R"("CFICode": )"; - builder << '"' << writer.getCFICodeAsJsonEscapedString().c_str() << '"'; + #else + template inline void forEach(Func&& func) + { + while (hasNext()) + { + next(); + func(*this); + } + } - builder << ", "; - builder << R"("MaturityMonthYear": )"; - builder << writer.maturityMonthYear(); + #endif - builder << ", "; - builder << R"("Currency": )"; - builder << '"' << writer.getCurrencyAsJsonEscapedString().c_str() << '"'; + SBE_NODISCARD static const char *LotTypeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("SecuritySubType": )"; - builder << '"' << writer.getSecuritySubTypeAsJsonEscapedString().c_str() - << '"'; + static SBE_CONSTEXPR std::uint16_t lotTypeId() SBE_NOEXCEPT + { + return 1093; + } - builder << ", "; - builder << R"("UserDefinedInstrument": )"; - if (std::isprint(writer.userDefinedInstrument())) { - builder << '"' << (char)writer.userDefinedInstrument() << '"'; - } else { - builder << (int)writer.userDefinedInstrument(); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lotTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - builder << ", "; - builder << R"("MatchAlgorithm": )"; - if (std::isprint(writer.matchAlgorithm())) { - builder << '"' << (char)writer.matchAlgorithm() << '"'; - } else { - builder << (int)writer.matchAlgorithm(); - } + SBE_NODISCARD bool lotTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= lotTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - builder << ", "; - builder << R"("MinTradeVol": )"; - builder << +writer.minTradeVol(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lotTypeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - builder << ", "; - builder << R"("MaxTradeVol": )"; - builder << +writer.maxTradeVol(); + static SBE_CONSTEXPR std::int8_t lotTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } - builder << ", "; - builder << R"("MinPriceIncrement": )"; - builder << writer.minPriceIncrement(); + static SBE_CONSTEXPR std::int8_t lotTypeMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } - builder << ", "; - builder << R"("DisplayFactor": )"; - builder << writer.displayFactor(); + static SBE_CONSTEXPR std::int8_t lotTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } - builder << ", "; - builder << R"("PriceDisplayFormat": )"; - builder << +writer.priceDisplayFormat(); + static SBE_CONSTEXPR std::size_t lotTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } - builder << ", "; - builder << R"("PriceRatio": )"; - builder << writer.priceRatio(); + SBE_NODISCARD std::int8_t lotType() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 0, sizeof(std::int8_t)); + return (val); + } - builder << ", "; - builder << R"("TickRule": )"; - builder << +writer.tickRule(); + NoLotTypeRules &lotType(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 0, &val, sizeof(std::int8_t)); + return *this; + } - builder << ", "; - builder << R"("UnitOfMeasure": )"; - builder << '"' << writer.getUnitOfMeasureAsJsonEscapedString().c_str() - << '"'; + SBE_NODISCARD static const char *MinLotSizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - builder << ", "; - builder << R"("TradingReferencePrice": )"; - builder << writer.tradingReferencePrice(); + static SBE_CONSTEXPR std::uint16_t minLotSizeId() SBE_NOEXCEPT + { + return 1231; + } - builder << ", "; - builder << R"("SettlPriceType": )"; - builder << writer.settlPriceType(); + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t minLotSizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - builder << ", "; - builder << R"("OpenInterestQty": )"; - builder << +writer.openInterestQty(); + SBE_NODISCARD bool minLotSizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= minLotSizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } - builder << ", "; - builder << R"("ClearedVolume": )"; - builder << +writer.clearedVolume(); + SBE_NODISCARD static SBE_CONSTEXPR std::size_t minLotSizeEncodingOffset() SBE_NOEXCEPT + { + return 1; + } - builder << ", "; - builder << R"("HighLimitPrice": )"; - builder << writer.highLimitPrice(); +private: + DecimalQty m_minLotSize; - builder << ", "; - builder << R"("LowLimitPrice": )"; - builder << writer.lowLimitPrice(); +public: + SBE_NODISCARD DecimalQty &minLotSize() + { + m_minLotSize.wrap(m_buffer, m_offset + 1, m_actingVersion, m_bufferLength); + return m_minLotSize; + } - builder << ", "; - builder << R"("MaxPriceVariation": )"; - builder << writer.maxPriceVariation(); + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoLotTypeRules writer) + { + builder << '{'; + builder << R"("LotType": )"; + builder << +writer.lotType(); - builder << ", "; - builder << R"("MainFraction": )"; - builder << +writer.mainFraction(); + builder << ", "; + builder << R"("MinLotSize": )"; + builder << writer.minLotSize(); - builder << ", "; - builder << R"("SubFraction": )"; - builder << +writer.subFraction(); + builder << '}'; - builder << ", "; - builder << R"("TradingReferenceDate": )"; - builder << +writer.tradingReferenceDate(); + return builder; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoEvents": [)"; - writer.noEvents().forEach([&](NoEvents &noEvents) { - if (atLeastOne) { - 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: + NoLotTypeRules m_noLotTypeRules; + +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoLotTypeRulesId() SBE_NOEXCEPT + { + return 1234; + } + + SBE_NODISCARD inline NoLotTypeRules &noLotTypeRules() + { + m_noLotTypeRules.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLotTypeRules; + } + + NoLotTypeRules &noLotTypeRulesCount(const std::uint8_t count) + { + m_noLotTypeRules.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noLotTypeRules; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noLotTypeRulesSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool noLotTypeRulesInActingVersion() const SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= noLotTypeRulesSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + + 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(18)); + dimensions.numInGroup(static_cast(count)); + m_index = 0; + m_count = count; + m_blockLength = 18; + 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 18; + } + + 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() SBE_NOEXCEPT + { + m_count = m_index; + GroupSize dimensions(m_buffer, m_initialPosition, m_bufferLength, m_actingVersion); + dimensions.numInGroup(static_cast(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 *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 0; + } + + 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 + 0, 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 + 0, &val, sizeof(std::int32_t)); + return *this; + } + + 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 4; + } + + 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 }; + + return (const char *)legSecurityIDSourceValues; + } + + SBE_NODISCARD char legSecurityIDSource(const std::uint64_t index) const + { + static const std::uint8_t legSecurityIDSourceValues[] = { 56 }; + + 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 *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 4; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t legSideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD LegSide::Value legSide() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 4, sizeof(std::uint8_t)); + return LegSide::get((val)); + } + + NoLegs &legSide(const LegSide::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 4, &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 "Qty"; + case MetaAttribute::PRESENCE: return "required"; + 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 5; + } + + static SBE_CONSTEXPR std::int8_t legRatioQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t legRatioQtyMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t legRatioQtyMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t legRatioQtyEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::int8_t legRatioQty() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 5, sizeof(std::int8_t)); + return (val); + } + + NoLegs &legRatioQty(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 5, &val, sizeof(std::int8_t)); + return *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 9; + } + + 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 6; + } + +private: + PRICENULL9 m_legPrice; + +public: + SBE_NODISCARD PRICENULL9 &legPrice() + { + m_legPrice.wrap(m_buffer, m_offset + 6, 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 "Qty"; + 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 14; + } + +private: + DecimalQty m_legOptionDelta; + +public: + SBE_NODISCARD DecimalQty &legOptionDelta() + { + m_legOptionDelta.wrap(m_buffer, m_offset + 14, m_actingVersion, m_bufferLength); + return m_legOptionDelta; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoLegs writer) + { + builder << '{'; + builder << R"("LegSecurityID": )"; + builder << +writer.legSecurityID(); + + builder << ", "; + builder << R"("LegSide": )"; + builder << '"' << writer.legSide() << '"'; + + builder << ", "; + builder << R"("LegRatioQty": )"; + builder << +writer.legRatioQty(); + + builder << ", "; + builder << R"("LegPrice": )"; + builder << writer.legPrice(); + + builder << ", "; + builder << R"("LegOptionDelta": )"; + builder << writer.legOptionDelta(); + + 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: + NoLegs m_noLegs; + +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; + } + + 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 bool noLegsInActingVersion() const SBE_NOEXCEPT + { +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wtautological-compare" +#endif + return m_actingVersion >= noLegsSinceVersion(); +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MDInstrumentDefinitionSpread56 _writer) +{ + MDInstrumentDefinitionSpread56 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "MDInstrumentDefinitionSpread56", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); + + builder << ", "; + builder << R"("TotNumReports": )"; + builder << +writer.totNumReports(); + + builder << ", "; + builder << R"("SecurityUpdateAction": )"; + builder << '"' << writer.securityUpdateAction() << '"'; + + builder << ", "; + builder << R"("LastUpdateTime": )"; + builder << +writer.lastUpdateTime(); + + builder << ", "; + builder << R"("MDSecurityTradingStatus": )"; + builder << '"' << writer.mDSecurityTradingStatus() << '"'; + + builder << ", "; + builder << R"("ApplID": )"; + builder << +writer.applID(); + + builder << ", "; + builder << R"("MarketSegmentID": )"; + builder << +writer.marketSegmentID(); + + builder << ", "; + builder << R"("UnderlyingProduct": )"; + builder << +writer.underlyingProduct(); + + builder << ", "; + builder << R"("SecurityExchange": )"; + builder << '"' << + writer.getSecurityExchangeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityGroup": )"; + builder << '"' << + writer.getSecurityGroupAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("Asset": )"; + builder << '"' << + writer.getAssetAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("Symbol": )"; + builder << '"' << + writer.getSymbolAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("SecurityType": )"; + builder << '"' << + writer.getSecurityTypeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("CFICode": )"; + builder << '"' << + writer.getCFICodeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("MaturityMonthYear": )"; + builder << writer.maturityMonthYear(); + + builder << ", "; + builder << R"("Currency": )"; + builder << '"' << + writer.getCurrencyAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecuritySubType": )"; + builder << '"' << + writer.getSecuritySubTypeAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("UserDefinedInstrument": )"; + if (std::isprint(writer.userDefinedInstrument())) + { + builder << '"' << (char)writer.userDefinedInstrument() << '"'; + } + else + { + builder << (int)writer.userDefinedInstrument(); + } + + builder << ", "; + builder << R"("MatchAlgorithm": )"; + if (std::isprint(writer.matchAlgorithm())) + { + builder << '"' << (char)writer.matchAlgorithm() << '"'; + } + else + { + builder << (int)writer.matchAlgorithm(); + } + + builder << ", "; + builder << R"("MinTradeVol": )"; + builder << +writer.minTradeVol(); + + builder << ", "; + builder << R"("MaxTradeVol": )"; + builder << +writer.maxTradeVol(); + + builder << ", "; + builder << R"("MinPriceIncrement": )"; + builder << writer.minPriceIncrement(); + + builder << ", "; + builder << R"("DisplayFactor": )"; + builder << writer.displayFactor(); + + builder << ", "; + builder << R"("PriceDisplayFormat": )"; + builder << +writer.priceDisplayFormat(); + + builder << ", "; + builder << R"("PriceRatio": )"; + builder << writer.priceRatio(); + + builder << ", "; + builder << R"("TickRule": )"; + builder << +writer.tickRule(); + + builder << ", "; + builder << R"("UnitOfMeasure": )"; + builder << '"' << + writer.getUnitOfMeasureAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("TradingReferencePrice": )"; + builder << writer.tradingReferencePrice(); + + builder << ", "; + builder << R"("SettlPriceType": )"; + builder << writer.settlPriceType(); + + builder << ", "; + builder << R"("OpenInterestQty": )"; + builder << +writer.openInterestQty(); + + builder << ", "; + builder << R"("ClearedVolume": )"; + builder << +writer.clearedVolume(); + + builder << ", "; + builder << R"("HighLimitPrice": )"; + builder << writer.highLimitPrice(); + + builder << ", "; + builder << R"("LowLimitPrice": )"; + builder << writer.lowLimitPrice(); + + builder << ", "; + builder << R"("MaxPriceVariation": )"; + builder << writer.maxPriceVariation(); + + builder << ", "; + builder << R"("MainFraction": )"; + builder << +writer.mainFraction(); + + builder << ", "; + builder << R"("SubFraction": )"; + builder << +writer.subFraction(); + + builder << ", "; + builder << R"("TradingReferenceDate": )"; + builder << +writer.tradingReferenceDate(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoEvents": [)"; + writer.noEvents().forEach([&](NoEvents& noEvents) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noEvents; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDFeedTypes": [)"; - writer.noMDFeedTypes().forEach([&](NoMDFeedTypes &noMDFeedTypes) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDFeedTypes": [)"; + writer.noMDFeedTypes().forEach([&](NoMDFeedTypes& noMDFeedTypes) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDFeedTypes; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoInstAttrib": [)"; - writer.noInstAttrib().forEach([&](NoInstAttrib &noInstAttrib) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoInstAttrib": [)"; + writer.noInstAttrib().forEach([&](NoInstAttrib& noInstAttrib) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noInstAttrib; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoLotTypeRules": [)"; - writer.noLotTypeRules().forEach([&](NoLotTypeRules &noLotTypeRules) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoLotTypeRules": [)"; + writer.noLotTypeRules().forEach([&](NoLotTypeRules& noLotTypeRules) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noLotTypeRules; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoLegs": [)"; - writer.noLegs().forEach([&](NoLegs &noLegs) { - if (atLeastOne) { - builder << ", "; + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoLegs": [)"; + writer.noLegs().forEach([&](NoLegs& noLegs) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noLegs; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noEvents().forEach([](NoEvents e) + { + e.skip(); + }); + noMDFeedTypes().forEach([](NoMDFeedTypes e) + { + e.skip(); + }); + noInstAttrib().forEach([](NoInstAttrib e) + { + e.skip(); + }); + noLotTypeRules().forEach([](NoLotTypeRules e) + { + e.skip(); + }); + noLegs().forEach([](NoLegs e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength( + std::size_t noEventsLength = 0, + std::size_t noMDFeedTypesLength = 0, + std::size_t noInstAttribLength = 0, + std::size_t noLotTypeRulesLength = 0, + std::size_t noLegsLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoEvents::sbeHeaderSize(); + if (noEventsLength > 254LL) + { + throw std::runtime_error("noEventsLength outside of allowed range [E110]"); + } + length += noEventsLength *NoEvents::sbeBlockLength(); + + length += NoMDFeedTypes::sbeHeaderSize(); + if (noMDFeedTypesLength > 254LL) + { + throw std::runtime_error("noMDFeedTypesLength outside of allowed range [E110]"); + } + length += noMDFeedTypesLength *NoMDFeedTypes::sbeBlockLength(); + + length += NoInstAttrib::sbeHeaderSize(); + if (noInstAttribLength > 254LL) + { + throw std::runtime_error("noInstAttribLength outside of allowed range [E110]"); + } + length += noInstAttribLength *NoInstAttrib::sbeBlockLength(); + + length += NoLotTypeRules::sbeHeaderSize(); + if (noLotTypeRulesLength > 254LL) + { + throw std::runtime_error("noLotTypeRulesLength outside of allowed range [E110]"); + } + length += noLotTypeRulesLength *NoLotTypeRules::sbeBlockLength(); + + length += NoLegs::sbeHeaderSize(); + if (noLegsLength > 254LL) + { + throw std::runtime_error("noLegsLength outside of allowed range [E110]"); + } + length += noLegsLength *NoLegs::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDUpdateAction.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDUpdateAction.h index 922c38d04..84fb6928a 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MDUpdateAction.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MDUpdateAction.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,69 +86,63 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class MDUpdateAction { - public: - enum Value { - New = (std::uint8_t)0, - Change = (std::uint8_t)1, - Delete = (std::uint8_t)2, - DeleteThru = (std::uint8_t)3, - DeleteFrom = (std::uint8_t)4, - Overlay = (std::uint8_t)5, - NULL_VALUE = (std::uint8_t)255 - }; +class MDUpdateAction +{ +public: + enum Value + { + New = static_cast(0), + Change = static_cast(1), + Delete = static_cast(2), + DeleteThru = static_cast(3), + DeleteFrom = static_cast(4), + Overlay = static_cast(5), + NULL_VALUE = static_cast(255) + }; - static MDUpdateAction::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return New; - case 1: - return Change; - case 2: - return Delete; - case 3: - return DeleteThru; - case 4: - return DeleteFrom; - case 5: - return Overlay; - case 255: - return NULL_VALUE; - } + static MDUpdateAction::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return New; + case static_cast(1): return Change; + case static_cast(2): return Delete; + case static_cast(3): return DeleteThru; + case static_cast(4): return DeleteFrom; + case static_cast(5): return Overlay; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum MDUpdateAction [E103]"); - } + throw std::runtime_error("unknown value for enum MDUpdateAction [E103]"); + } - static const char *c_str(const MDUpdateAction::Value value) { - switch (value) { - case New: - return "New"; - case Change: - return "Change"; - case Delete: - return "Delete"; - case DeleteThru: - return "DeleteThru"; - case DeleteFrom: - return "DeleteFrom"; - case Overlay: - return "Overlay"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const MDUpdateAction::Value value) + { + switch (value) + { + case New: return "New"; + case Change: return "Change"; + case Delete: return "Delete"; + case DeleteThru: return "DeleteThru"; + case DeleteFrom: return "DeleteFrom"; + case Overlay: return "Overlay"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum MDUpdateAction [E103]:"); - } + throw std::runtime_error("unknown value for enum MDUpdateAction [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, MDUpdateAction::Value m) { - return os << MDUpdateAction::c_str(m); - } + template + friend std::basic_ostream& operator << ( + std::basic_ostream& os, MDUpdateAction::Value m) + { + return os << MDUpdateAction::c_str(m); + } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MatchEventIndicator.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MatchEventIndicator.h index 821a68b73..3026be6af 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MatchEventIndicator.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MatchEventIndicator.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,373 +86,428 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class MatchEventIndicator { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; +class MatchEventIndicator +{ +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; + }; - MatchEventIndicator() = default; + MatchEventIndicator() = default; - MatchEventIndicator( - 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]"); - } - } + MatchEventIndicator( + 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]"); + } + } - MatchEventIndicator( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : MatchEventIndicator(buffer, 0, bufferLength, actingVersion) {} + MatchEventIndicator( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + MatchEventIndicator(buffer, 0, bufferLength, actingVersion) + { + } - MatchEventIndicator(char *buffer, const std::uint64_t bufferLength) - : MatchEventIndicator(buffer, 0, bufferLength, sbeSchemaVersion()) {} + MatchEventIndicator( + char *buffer, + const std::uint64_t bufferLength) : + MatchEventIndicator(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } - MatchEventIndicator &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = MatchEventIndicator( - buffer, offset, bufferLength, actingVersion); - } + MatchEventIndicator &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = MatchEventIndicator(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)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - MatchEventIndicator &clear() { - std::uint8_t zero = 0; - std::memcpy(m_buffer + m_offset, &zero, sizeof(std::uint8_t)); - return *this; - } + MatchEventIndicator &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; + } - MatchEventIndicator &rawValue(std::uint8_t value) { - std::memcpy(m_buffer + m_offset, &value, sizeof(std::uint8_t)); - return *this; - } + MatchEventIndicator &rawValue(std::uint8_t value) + { + std::memcpy(m_buffer + m_offset, &value, sizeof(std::uint8_t)); + return *this; + } - static bool lastTradeMsg(const std::uint8_t bits) { - return (bits & (1u << 0u)) != 0; - } + static bool lastTradeMsg(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 0u)) != 0; + } - static std::uint8_t lastTradeMsg(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 0u)) - : static_cast(bits & ~(1u << 0u)); - } + static std::uint8_t lastTradeMsg(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 lastTradeMsg() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 0u)) != 0; - } + SBE_NODISCARD bool lastTradeMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 0u)) != 0; + } - MatchEventIndicator &lastTradeMsg(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; - } + MatchEventIndicator &lastTradeMsg(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 lastVolumeMsg(const std::uint8_t bits) { - return (bits & (1u << 1u)) != 0; - } + static bool lastVolumeMsg(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 1u)) != 0; + } - static std::uint8_t - lastVolumeMsg(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 1u)) - : static_cast(bits & ~(1u << 1u)); - } + static std::uint8_t lastVolumeMsg(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 lastVolumeMsg() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 1u)) != 0; - } + SBE_NODISCARD bool lastVolumeMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 1u)) != 0; + } - MatchEventIndicator &lastVolumeMsg(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; - } + MatchEventIndicator &lastVolumeMsg(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 lastQuoteMsg(const std::uint8_t bits) { - return (bits & (1u << 2u)) != 0; - } + static bool lastQuoteMsg(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 2u)) != 0; + } - static std::uint8_t lastQuoteMsg(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 2u)) - : static_cast(bits & ~(1u << 2u)); - } + static std::uint8_t lastQuoteMsg(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 lastQuoteMsg() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 2u)) != 0; - } + SBE_NODISCARD bool lastQuoteMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 2u)) != 0; + } - MatchEventIndicator &lastQuoteMsg(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; - } + MatchEventIndicator &lastQuoteMsg(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 lastStatsMsg(const std::uint8_t bits) { - return (bits & (1u << 3u)) != 0; - } + static bool lastStatsMsg(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 3u)) != 0; + } - static std::uint8_t lastStatsMsg(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 3u)) - : static_cast(bits & ~(1u << 3u)); - } + static std::uint8_t lastStatsMsg(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 lastStatsMsg() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 3u)) != 0; - } + SBE_NODISCARD bool lastStatsMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 3u)) != 0; + } - MatchEventIndicator &lastStatsMsg(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; - } + MatchEventIndicator &lastStatsMsg(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 lastImpliedMsg(const std::uint8_t bits) { - return (bits & (1u << 4u)) != 0; - } + static bool lastImpliedMsg(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 4u)) != 0; + } - static std::uint8_t - lastImpliedMsg(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 4u)) - : static_cast(bits & ~(1u << 4u)); - } + static std::uint8_t lastImpliedMsg(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 lastImpliedMsg() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 4u)) != 0; - } + SBE_NODISCARD bool lastImpliedMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 4u)) != 0; + } - MatchEventIndicator &lastImpliedMsg(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; - } + MatchEventIndicator &lastImpliedMsg(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 recoveryMsg(const std::uint8_t bits) { - return (bits & (1u << 5u)) != 0; - } + static bool recoveryMsg(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 5u)) != 0; + } - static std::uint8_t recoveryMsg(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 5u)) - : static_cast(bits & ~(1u << 5u)); - } + static std::uint8_t recoveryMsg(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 recoveryMsg() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 5u)) != 0; - } + SBE_NODISCARD bool recoveryMsg() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 5u)) != 0; + } - MatchEventIndicator &recoveryMsg(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; - } + MatchEventIndicator &recoveryMsg(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 reserved(const std::uint8_t bits) { - return (bits & (1u << 6u)) != 0; - } + static bool reserved(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 6u)) != 0; + } - static std::uint8_t reserved(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 6u)) - : static_cast(bits & ~(1u << 6u)); - } + static std::uint8_t reserved(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 reserved() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 6u)) != 0; - } + SBE_NODISCARD bool reserved() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 6u)) != 0; + } - MatchEventIndicator &reserved(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; - } + MatchEventIndicator &reserved(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 endOfEvent(const std::uint8_t bits) { - return (bits & (1u << 7u)) != 0; - } + static bool endOfEvent(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 7u)) != 0; + } - static std::uint8_t endOfEvent(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 7u)) - : static_cast(bits & ~(1u << 7u)); - } + static std::uint8_t endOfEvent(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 endOfEvent() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 7u)) != 0; - } + SBE_NODISCARD bool endOfEvent() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 7u)) != 0; + } - MatchEventIndicator &endOfEvent(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; - } + MatchEventIndicator &endOfEvent(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, MatchEventIndicator writer) { - builder << '['; - bool atLeastOne = false; - if (writer.lastTradeMsg()) { - builder << R"("lastTradeMsg")"; - atLeastOne = true; - } - if (writer.lastVolumeMsg()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("lastVolumeMsg")"; - atLeastOne = true; - } - if (writer.lastQuoteMsg()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("lastQuoteMsg")"; - atLeastOne = true; - } - if (writer.lastStatsMsg()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("lastStatsMsg")"; - atLeastOne = true; - } - if (writer.lastImpliedMsg()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("lastImpliedMsg")"; - atLeastOne = true; - } - if (writer.recoveryMsg()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("recoveryMsg")"; - atLeastOne = true; - } - if (writer.reserved()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("reserved")"; - atLeastOne = true; - } - if (writer.endOfEvent()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("endOfEvent")"; - } - builder << ']'; - return builder; - } + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, MatchEventIndicator writer) + { + builder << '['; + bool atLeastOne = false; + if (writer.lastTradeMsg()) + { + builder << R"("lastTradeMsg")"; + atLeastOne = true; + } + if (writer.lastVolumeMsg()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("lastVolumeMsg")"; + atLeastOne = true; + } + if (writer.lastQuoteMsg()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("lastQuoteMsg")"; + atLeastOne = true; + } + if (writer.lastStatsMsg()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("lastStatsMsg")"; + atLeastOne = true; + } + if (writer.lastImpliedMsg()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("lastImpliedMsg")"; + atLeastOne = true; + } + if (writer.recoveryMsg()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("recoveryMsg")"; + atLeastOne = true; + } + if (writer.reserved()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("reserved")"; + atLeastOne = true; + } + if (writer.endOfEvent()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("endOfEvent")"; + } + builder << ']'; + return builder; + } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MaturityMonthYear.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MaturityMonthYear.h index 72c38ffb0..9cdb5733d 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MaturityMonthYear.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MaturityMonthYear.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,349 +86,424 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -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)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - yearSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t yearId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool yearInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t yearSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - monthSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t monthId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool monthInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t monthSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - daySinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t dayId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool dayInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t daySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - weekSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t weekId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool weekInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t weekSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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 mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/MessageHeader.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/MessageHeader.h index 324faa08b..aa223e515 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/MessageHeader.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/MessageHeader.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,348 +86,424 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -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)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - blockLengthSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t blockLengthId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool blockLengthInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t blockLengthSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - templateIdSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t templateIdId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool templateIdInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t templateIdSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - schemaIdSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t schemaIdId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool schemaIdInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t schemaIdSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - versionSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t versionId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool versionInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t versionSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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 mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/OpenCloseSettlFlag.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/OpenCloseSettlFlag.h index afcbb560d..26e68ef75 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/OpenCloseSettlFlag.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/OpenCloseSettlFlag.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,51 +86,51 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class OpenCloseSettlFlag { - public: - enum Value { - DailyOpenPrice = (std::uint8_t)0, - IndicativeOpeningPrice = (std::uint8_t)5, - NULL_VALUE = (std::uint8_t)255 - }; +class OpenCloseSettlFlag +{ +public: + enum Value + { + DailyOpenPrice = static_cast(0), + IndicativeOpeningPrice = static_cast(5), + NULL_VALUE = static_cast(255) + }; - static OpenCloseSettlFlag::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return DailyOpenPrice; - case 5: - return IndicativeOpeningPrice; - case 255: - return NULL_VALUE; - } + static OpenCloseSettlFlag::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return DailyOpenPrice; + case static_cast(5): return IndicativeOpeningPrice; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error( - "unknown value for enum OpenCloseSettlFlag [E103]"); - } + throw std::runtime_error("unknown value for enum OpenCloseSettlFlag [E103]"); + } - static const char *c_str(const OpenCloseSettlFlag::Value value) { - switch (value) { - case DailyOpenPrice: - return "DailyOpenPrice"; - case IndicativeOpeningPrice: - return "IndicativeOpeningPrice"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const OpenCloseSettlFlag::Value value) + { + switch (value) + { + case DailyOpenPrice: return "DailyOpenPrice"; + case IndicativeOpeningPrice: return "IndicativeOpeningPrice"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum OpenCloseSettlFlag [E103]:"); - } + throw std::runtime_error("unknown value for enum OpenCloseSettlFlag [E103]:"); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &os, OpenCloseSettlFlag::Value m) { - return os << OpenCloseSettlFlag::c_str(m); - } + template + friend std::basic_ostream& operator << ( + std::basic_ostream& os, OpenCloseSettlFlag::Value m) + { + return os << OpenCloseSettlFlag::c_str(m); + } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/OrderUpdateAction.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/OrderUpdateAction.h index b58e74c94..48e32dd7e 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/OrderUpdateAction.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/OrderUpdateAction.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,56 +86,54 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class OrderUpdateAction { - public: - enum Value { - New = (std::uint8_t)0, - Update = (std::uint8_t)1, - Delete = (std::uint8_t)2, - NULL_VALUE = (std::uint8_t)255 - }; +class OrderUpdateAction +{ +public: + enum Value + { + New = static_cast(0), + Update = static_cast(1), + Delete = static_cast(2), + NULL_VALUE = static_cast(255) + }; - static OrderUpdateAction::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return New; - case 1: - return Update; - case 2: - return Delete; - case 255: - return NULL_VALUE; - } + static OrderUpdateAction::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return New; + case static_cast(1): return Update; + case static_cast(2): return Delete; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error( - "unknown value for enum OrderUpdateAction [E103]"); - } + throw std::runtime_error("unknown value for enum OrderUpdateAction [E103]"); + } - static const char *c_str(const OrderUpdateAction::Value value) { - switch (value) { - case New: - return "New"; - case Update: - return "Update"; - case Delete: - return "Delete"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const OrderUpdateAction::Value value) + { + switch (value) + { + case New: return "New"; + case Update: return "Update"; + case Delete: return "Delete"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum OrderUpdateAction [E103]:"); - } + throw std::runtime_error("unknown value for enum OrderUpdateAction [E103]:"); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &os, OrderUpdateAction::Value m) { - return os << OrderUpdateAction::c_str(m); - } + template + friend std::basic_ostream& operator << ( + std::basic_ostream& os, OrderUpdateAction::Value m) + { + return os << OrderUpdateAction::c_str(m); + } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/PRICE.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/PRICE.h index e950f28ac..512d1a6c6 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/PRICE.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/PRICE.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,210 +86,263 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class PRICE { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; +class PRICE +{ +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; + }; - PRICE() = default; + PRICE() = default; - PRICE( - 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]"); - } - } + PRICE( + 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]"); + } + } - PRICE( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : PRICE(buffer, 0, bufferLength, actingVersion) {} + PRICE( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + PRICE(buffer, 0, bufferLength, actingVersion) + { + } - PRICE(char *buffer, const std::uint64_t bufferLength) - : PRICE(buffer, 0, bufferLength, sbeSchemaVersion()) {} + PRICE( + char *buffer, + const std::uint64_t bufferLength) : + PRICE(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } - PRICE &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = PRICE(buffer, offset, bufferLength, actingVersion); - } + PRICE &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = PRICE(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)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mantissaSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t mantissaId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool mantissaInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mantissaSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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); + } - PRICE &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; - } + PRICE &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 ""; + } + } - 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 0; + } + + 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)-7; - } + SBE_NODISCARD static SBE_CONSTEXPR std::int8_t exponent() SBE_NOEXCEPT + { + return static_cast(-7); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, PRICE writer) { - builder << '{'; - builder << R"("mantissa": )"; - builder << +writer.mantissa(); +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, PRICE writer) +{ + builder << '{'; + builder << R"("mantissa": )"; + builder << +writer.mantissa(); - builder << '}'; + builder << '}'; + + return builder; +} - return builder; - } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/PRICE9.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/PRICE9.h index 67938cc33..887ad2678 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/PRICE9.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/PRICE9.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,210 +86,263 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -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)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mantissaSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t mantissaId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool mantissaInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mantissaSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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 ""; + } + } - 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 0; + } + + 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 mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/PRICENULL.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/PRICENULL.h index 4cd93e979..8d659ca3c 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/PRICENULL.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/PRICENULL.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,210 +86,263 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class PRICENULL { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; +class PRICENULL +{ +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; + }; - PRICENULL() = default; + PRICENULL() = default; - PRICENULL( - 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]"); - } - } + PRICENULL( + 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]"); + } + } - PRICENULL( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : PRICENULL(buffer, 0, bufferLength, actingVersion) {} + PRICENULL( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + PRICENULL(buffer, 0, bufferLength, actingVersion) + { + } - PRICENULL(char *buffer, const std::uint64_t bufferLength) - : PRICENULL(buffer, 0, bufferLength, sbeSchemaVersion()) {} + PRICENULL( + char *buffer, + const std::uint64_t bufferLength) : + PRICENULL(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } - PRICENULL &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = PRICENULL(buffer, offset, bufferLength, actingVersion); - } + PRICENULL &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = PRICENULL(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)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mantissaSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t mantissaId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool mantissaInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mantissaSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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); + } - PRICENULL &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; - } + PRICENULL &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 ""; + } + } - 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 0; + } + + 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)-7; - } + SBE_NODISCARD static SBE_CONSTEXPR std::int8_t exponent() SBE_NOEXCEPT + { + return static_cast(-7); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &builder, PRICENULL writer) { - builder << '{'; - builder << R"("mantissa": )"; - builder << +writer.mantissa(); +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, PRICENULL writer) +{ + builder << '{'; + builder << R"("mantissa": )"; + builder << +writer.mantissa(); - builder << '}'; + builder << '}'; + + return builder; +} - return builder; - } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/PRICENULL9.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/PRICENULL9.h index bf0d504dd..6d26c12c1 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/PRICENULL9.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/PRICENULL9.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,210 +86,263 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -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)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - 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 ""; + } + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mantissaSinceVersion() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint16_t mantissaId() SBE_NOEXCEPT + { + return -1; + } - SBE_NODISCARD bool mantissaInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mantissaSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + 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 ""; + } + } - 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 0; + } + + 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 mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/PutOrCall.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/PutOrCall.h index 23b35a708..e5d2e0bfb 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/PutOrCall.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/PutOrCall.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,49 +86,51 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class PutOrCall { - public: - enum Value { - Put = (std::uint8_t)0, - Call = (std::uint8_t)1, - NULL_VALUE = (std::uint8_t)255 - }; +class PutOrCall +{ +public: + enum Value + { + Put = static_cast(0), + Call = static_cast(1), + NULL_VALUE = static_cast(255) + }; - static PutOrCall::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return Put; - case 1: - return Call; - case 255: - return NULL_VALUE; - } + static PutOrCall::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return Put; + case static_cast(1): return Call; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error("unknown value for enum PutOrCall [E103]"); - } + throw std::runtime_error("unknown value for enum PutOrCall [E103]"); + } - static const char *c_str(const PutOrCall::Value value) { - switch (value) { - case Put: - return "Put"; - case Call: - return "Call"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const PutOrCall::Value value) + { + switch (value) + { + case Put: return "Put"; + case Call: return "Call"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error("unknown value for enum PutOrCall [E103]:"); - } + throw std::runtime_error("unknown value for enum PutOrCall [E103]:"); + } - template - friend std::basic_ostream & - operator<<(std::basic_ostream &os, PutOrCall::Value m) { - return os << PutOrCall::c_str(m); - } + template + friend std::basic_ostream& operator << ( + std::basic_ostream& os, PutOrCall::Value m) + { + return os << PutOrCall::c_str(m); + } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/QuoteRequest39.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/QuoteRequest39.h index 32da45139..ff2f38b7d 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/QuoteRequest39.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/QuoteRequest39.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,1189 +86,1374 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class QuoteRequest39 { - 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 QuoteRequest39 +{ +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; } + 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(35); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(39); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - QuoteRequest39() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - QuoteRequest39( - 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; - QuoteRequest39(char *buffer, const std::uint64_t bufferLength) - : QuoteRequest39( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + QuoteRequest39() = default; - QuoteRequest39( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : QuoteRequest39( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + QuoteRequest39( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)35; - } + QuoteRequest39(char *buffer, const std::uint64_t bufferLength) : + QuoteRequest39(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)39; - } + QuoteRequest39( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + QuoteRequest39(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(35); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "R"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(39); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - QuoteRequest39 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = QuoteRequest39( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - QuoteRequest39 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "R"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = QuoteRequest39( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + QuoteRequest39 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = QuoteRequest39(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - QuoteRequest39 &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 = QuoteRequest39( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + QuoteRequest39 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = QuoteRequest39( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + QuoteRequest39 &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 = QuoteRequest39(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + QuoteRequest39 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + 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(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - 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 + 0, 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - QuoteRequest39 &transactTime(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; - } + QuoteRequest39 &transactTime(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 "String"; - 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 "String"; + 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 char quoteReqIDNullValue() SBE_NOEXCEPT { - return (char)0; - } + static SBE_CONSTEXPR char quoteReqIDNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char quoteReqIDMinValue() SBE_NOEXCEPT { - return (char)32; - } + static SBE_CONSTEXPR char quoteReqIDMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char quoteReqIDMaxValue() SBE_NOEXCEPT { - return (char)126; - } + static SBE_CONSTEXPR char quoteReqIDMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t quoteReqIDEncodingLength() SBE_NOEXCEPT { - return 23; - } + static SBE_CONSTEXPR std::size_t quoteReqIDEncodingLength() SBE_NOEXCEPT + { + return 23; + } - static SBE_CONSTEXPR std::uint64_t quoteReqIDLength() SBE_NOEXCEPT { - return 23; - } + static SBE_CONSTEXPR std::uint64_t quoteReqIDLength() SBE_NOEXCEPT + { + return 23; + } - SBE_NODISCARD const char *quoteReqID() const SBE_NOEXCEPT { - return m_buffer + m_offset + 8; - } + SBE_NODISCARD const char *quoteReqID() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 8; + } - SBE_NODISCARD char *quoteReqID() SBE_NOEXCEPT { - return m_buffer + m_offset + 8; - } + SBE_NODISCARD char *quoteReqID() SBE_NOEXCEPT + { + return m_buffer + m_offset + 8; + } - SBE_NODISCARD char quoteReqID(const std::uint64_t index) const { - if (index >= 23) { - throw std::runtime_error("index out of range for quoteReqID [E104]"); - } + SBE_NODISCARD char quoteReqID(const std::uint64_t index) const + { + if (index >= 23) + { + throw std::runtime_error("index out of range for quoteReqID [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 8 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 8 + (index * 1), sizeof(char)); + return (val); + } - QuoteRequest39 "eReqID(const std::uint64_t index, const char value) { - if (index >= 23) { - throw std::runtime_error("index out of range for quoteReqID [E105]"); - } + QuoteRequest39 "eReqID(const std::uint64_t index, const char value) + { + if (index >= 23) + { + throw std::runtime_error("index out of range for quoteReqID [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 8 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 8 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t - getQuoteReqID(char *const dst, const std::uint64_t length) const { - if (length > 23) { - throw std::runtime_error("length too large for getQuoteReqID [E106]"); - } + std::uint64_t getQuoteReqID(char *const dst, const std::uint64_t length) const + { + if (length > 23) + { + throw std::runtime_error("length too large for getQuoteReqID [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 8, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 8, sizeof(char) * static_cast(length)); + return length; + } - QuoteRequest39 &putQuoteReqID(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 8, src, sizeof(char) * 23); - return *this; - } + QuoteRequest39 &putQuoteReqID(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 8, src, sizeof(char) * 23); + return *this; + } - std::string getQuoteReqIDAsString() const { - const char *buffer = m_buffer + m_offset + 8; - size_t length = 0; + SBE_NODISCARD std::string getQuoteReqIDAsString() const + { + const char *buffer = m_buffer + m_offset + 8; + size_t length = 0; - for (; length < 23 && *(buffer + length) != '\0'; ++length) - ; - std::string result(buffer, length); + for (; length < 23 && *(buffer + length) != '\0'; ++length); + std::string result(buffer, length); - return result; - } + return result; + } - std::string getQuoteReqIDAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getQuoteReqIDAsString(); + std::string getQuoteReqIDAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getQuoteReqIDAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getQuoteReqIDAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 8; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getQuoteReqIDAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 8; + size_t length = 0; - for (; length < 23 && *(buffer + length) != '\0'; ++length) - ; - std::string_view result(buffer, length); + for (; length < 23 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); - return result; - } -#endif + return result; + } + #endif -#if __cplusplus >= 201703L - QuoteRequest39 &putQuoteReqID(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 23) { - throw std::runtime_error("string too large for putQuoteReqID [E106]"); - } + #if __cplusplus >= 201703L + QuoteRequest39 &putQuoteReqID(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 23) + { + throw std::runtime_error("string too large for putQuoteReqID [E106]"); + } - std::memcpy(m_buffer + m_offset + 8, str.data(), srcLength); - for (size_t start = srcLength; start < 23; ++start) { - m_buffer[m_offset + 8 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 8, str.data(), srcLength); + for (size_t start = srcLength; start < 23; ++start) + { + m_buffer[m_offset + 8 + start] = 0; + } - return *this; - } -#else - QuoteRequest39 &putQuoteReqID(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 23) { - throw std::runtime_error("string too large for putQuoteReqID [E106]"); - } + return *this; + } + #else + QuoteRequest39 &putQuoteReqID(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 23) + { + throw std::runtime_error("string too large for putQuoteReqID [E106]"); + } - std::memcpy(m_buffer + m_offset + 8, str.c_str(), srcLength); - for (size_t start = srcLength; start < 23; ++start) { - m_buffer[m_offset + 8 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 8, str.c_str(), srcLength); + for (size_t start = srcLength; start < 23; ++start) + { + m_buffer[m_offset + 8 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char *MatchEventIndicatorMetaAttribute( - 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 *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 31; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 31; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 31, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 31, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - class NoRelatedSym { + 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 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(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; + } + + 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 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(static_cast(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 *SymbolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + 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 0; + } + + static SBE_CONSTEXPR char symbolNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR char symbolMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } + + static SBE_CONSTEXPR char symbolMaxValue() SBE_NOEXCEPT + { + return static_cast(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 + 0; + } + + SBE_NODISCARD char *symbol() SBE_NOEXCEPT + { + return m_buffer + m_offset + 0; + } + + 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 + 0 + (index * 1), sizeof(char)); + return (val); + } + + NoRelatedSym &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 + 0 + (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 + 0, sizeof(char) * static_cast(length)); + return length; + } + + NoRelatedSym &putSymbol(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 20); + return *this; + } + + SBE_NODISCARD std::string getSymbolAsString() 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 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 + 0; + size_t length = 0; + + for (; length < 20 && *(buffer + length) != '\0'; ++length); + std::string_view result(buffer, length); + + return result; + } + #endif + + #if __cplusplus >= 201703L + NoRelatedSym &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 + 0, str.data(), srcLength); + for (size_t start = srcLength; start < 20; ++start) + { + m_buffer[m_offset + 0 + start] = 0; + } + + return *this; + } + #else + NoRelatedSym &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 + 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 *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); + } + + 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 + 20, &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 "Qty"; + 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 24; + } + + static SBE_CONSTEXPR std::int32_t orderQtyNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t orderQtyMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t orderQtyMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t orderQty() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoRelatedSym &orderQty(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::int32_t)); + return *this; + } + + 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; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t quoteTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool quoteTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= quoteTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t quoteTypeEncodingOffset() SBE_NOEXCEPT + { + return 28; + } + + static SBE_CONSTEXPR std::int8_t quoteTypeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT8; + } + + static SBE_CONSTEXPR std::int8_t quoteTypeMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t quoteTypeMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t quoteTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::int8_t quoteType() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::int8_t)); + return (val); + } + + NoRelatedSym "eType(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::int8_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 "optional"; + 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 29; + } + + static SBE_CONSTEXPR std::int8_t sideNullValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::int8_t sideMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t sideMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::int8_t side() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 29, sizeof(std::int8_t)); + return (val); + } + + NoRelatedSym &side(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 29, &val, sizeof(std::int8_t)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoRelatedSym writer) + { + builder << '{'; + builder << R"("Symbol": )"; + builder << '"' << + writer.getSymbolAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("OrderQty": )"; + builder << +writer.orderQty(); + + builder << ", "; + builder << R"("QuoteType": )"; + builder << +writer.quoteType(); + + 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 - 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)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; - } +private: + NoRelatedSym m_noRelatedSym; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 32; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoRelatedSymId() SBE_NOEXCEPT + { + return 146; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoRelatedSym &noRelatedSym() + { + m_noRelatedSym.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noRelatedSym; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoRelatedSym &noRelatedSymCount(const std::uint8_t count) + { + m_noRelatedSym.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noRelatedSym; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noRelatedSymSinceVersion() 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 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 * - SymbolMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "String"; - case MetaAttribute::PRESENCE: - return "required"; - 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 { + SBE_NODISCARD bool noRelatedSymInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= symbolSinceVersion(); + return m_actingVersion >= noRelatedSymSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - symbolEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - 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 + 0; - } - - SBE_NODISCARD char *symbol() SBE_NOEXCEPT { - return m_buffer + m_offset + 0; - } - - 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 + 0 + (index * 1), sizeof(char)); - return (val); - } - - NoRelatedSym &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 + 0 + (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 + 0, - sizeof(char) * static_cast(length)); - return length; - } - - NoRelatedSym &putSymbol(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 0, src, sizeof(char) * 20); - return *this; - } - - std::string getSymbolAsString() 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 getSymbolAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getSymbolAsString(); - - 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 getSymbolAsStringView() 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 - NoRelatedSym &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 + 0, str.data(), srcLength); - for (size_t start = srcLength; start < 20; ++start) { - m_buffer[m_offset + 0 + start] = 0; - } - - return *this; - } -#else - NoRelatedSym &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 + 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 * - 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 -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 + 20, 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 + 20, &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 "Qty"; - 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 24; - } - - static SBE_CONSTEXPR std::int32_t orderQtyNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t orderQtyMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t orderQtyMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t orderQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t orderQty() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoRelatedSym &orderQty(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::int32_t)); - return *this; - } - - 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; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - quoteTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool quoteTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= quoteTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - quoteTypeEncodingOffset() SBE_NOEXCEPT { - return 28; - } - - static SBE_CONSTEXPR std::int8_t quoteTypeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT8; - } - - static SBE_CONSTEXPR std::int8_t quoteTypeMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t quoteTypeMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t quoteTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::int8_t quoteType() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::int8_t)); - return (val); - } - - NoRelatedSym "eType(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::int8_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 "optional"; - 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 29; - } - - static SBE_CONSTEXPR std::int8_t sideNullValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::int8_t sideMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t sideMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t sideEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::int8_t side() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 29, sizeof(std::int8_t)); - return (val); - } - - NoRelatedSym &side(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 29, &val, sizeof(std::int8_t)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoRelatedSym writer) { - builder << '{'; - builder << R"("Symbol": )"; - builder << '"' << writer.getSymbolAsJsonEscapedString().c_str() << '"'; - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("OrderQty": )"; - builder << +writer.orderQty(); - - builder << ", "; - builder << R"("QuoteType": )"; - builder << +writer.quoteType(); - - builder << ", "; - builder << R"("Side": )"; - builder << +writer.side(); - - builder << '}'; - - return builder; - } - }; - - 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, QuoteRequest39 _writer) { - QuoteRequest39 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "QuoteRequest39", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("QuoteReqID": )"; - builder << '"' << writer.getQuoteReqIDAsJsonEscapedString().c_str() - << '"'; - - builder << ", "; - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoRelatedSym": [)"; - writer.noRelatedSym().forEach([&](NoRelatedSym &noRelatedSym) { - if (atLeastOne) { - builder << ", "; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, QuoteRequest39 _writer) +{ + QuoteRequest39 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "QuoteRequest39", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("QuoteReqID": )"; + builder << '"' << + writer.getQuoteReqIDAsJsonEscapedString().c_str() << '"'; + + builder << ", "; + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoRelatedSym": [)"; + writer.noRelatedSym().forEach([&](NoRelatedSym& noRelatedSym) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noRelatedSym; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noRelatedSym().forEach([](NoRelatedSym e) + { + e.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 mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/SecurityStatus30.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/SecurityStatus30.h index 56ee04350..b8afea5d2 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/SecurityStatus30.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/SecurityStatus30.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,1027 +86,1150 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class SecurityStatus30 { - 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 SecurityStatus30 +{ +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; } + 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(30); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - SecurityStatus30() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - SecurityStatus30( - 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; - SecurityStatus30(char *buffer, const std::uint64_t bufferLength) - : SecurityStatus30( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + SecurityStatus30() = default; - SecurityStatus30( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : SecurityStatus30( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + SecurityStatus30( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)30; - } + SecurityStatus30(char *buffer, const std::uint64_t bufferLength) : + SecurityStatus30(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)30; - } + SecurityStatus30( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + SecurityStatus30(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(30); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "f"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(30); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SecurityStatus30 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = SecurityStatus30( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - SecurityStatus30 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "f"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = SecurityStatus30( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + SecurityStatus30 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = SecurityStatus30(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - SecurityStatus30 &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 = SecurityStatus30( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + SecurityStatus30 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = SecurityStatus30( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + SecurityStatus30 &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 = SecurityStatus30(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + SecurityStatus30 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t transactTimeId() SBE_NOEXCEPT { - return 60; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - transactTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool transactTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + 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(); + return m_actingVersion >= transactTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - transactTimeEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - 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 + 0, 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - SecurityStatus30 &transactTime(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; - } + SecurityStatus30 &transactTime(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 * - SecurityGroupMetaAttribute(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 *SecurityGroupMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + 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 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityGroupEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - 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 + 8; - } + SBE_NODISCARD const char *securityGroup() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 8; + } - SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT { - return m_buffer + m_offset + 8; - } + SBE_NODISCARD char *securityGroup() SBE_NOEXCEPT + { + return m_buffer + m_offset + 8; + } - 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 + 8 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 8 + (index * 1), sizeof(char)); + return (val); + } - SecurityStatus30 & - securityGroup(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error( - "index out of range for securityGroup [E105]"); - } + SecurityStatus30 &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 + 8 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 8 + (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 + 8, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 8, sizeof(char) * static_cast(length)); + return length; + } - SecurityStatus30 &putSecurityGroup(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 8, src, sizeof(char) * 6); - return *this; - } + SecurityStatus30 &putSecurityGroup(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 8, src, sizeof(char) * 6); + return *this; + } - std::string getSecurityGroupAsString() const { - const char *buffer = m_buffer + m_offset + 8; - size_t length = 0; + SBE_NODISCARD std::string getSecurityGroupAsString() const + { + const char *buffer = m_buffer + m_offset + 8; + 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 (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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getSecurityGroupAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 8; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getSecurityGroupAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 8; + 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 - SecurityStatus30 &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 + SecurityStatus30 &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 + 8, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 8 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 8, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 8 + start] = 0; + } - return *this; - } -#else - SecurityStatus30 &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 + SecurityStatus30 &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 + 8, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 8 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 8, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 8 + start] = 0; + } - return *this; - } -#endif + return *this; + } + #endif - SBE_NODISCARD static const char * - AssetMetaAttribute(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 *AssetMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t assetId() SBE_NOEXCEPT { return 6937; } + static SBE_CONSTEXPR std::uint16_t assetId() SBE_NOEXCEPT + { + return 6937; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - assetSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t assetSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool assetInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool assetInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= assetSinceVersion(); + return m_actingVersion >= assetSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - assetEncodingOffset() SBE_NOEXCEPT { - return 14; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t assetEncodingOffset() SBE_NOEXCEPT + { + return 14; + } - static SBE_CONSTEXPR char assetNullValue() SBE_NOEXCEPT { return (char)0; } + static SBE_CONSTEXPR char assetNullValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR char assetMinValue() SBE_NOEXCEPT { return (char)32; } + static SBE_CONSTEXPR char assetMinValue() SBE_NOEXCEPT + { + return static_cast(32); + } - static SBE_CONSTEXPR char assetMaxValue() SBE_NOEXCEPT { return (char)126; } + static SBE_CONSTEXPR char assetMaxValue() SBE_NOEXCEPT + { + return static_cast(126); + } - static SBE_CONSTEXPR std::size_t assetEncodingLength() SBE_NOEXCEPT { - return 6; - } + static SBE_CONSTEXPR std::size_t assetEncodingLength() SBE_NOEXCEPT + { + return 6; + } - static SBE_CONSTEXPR std::uint64_t assetLength() SBE_NOEXCEPT { return 6; } + static SBE_CONSTEXPR std::uint64_t assetLength() SBE_NOEXCEPT + { + return 6; + } - SBE_NODISCARD const char *asset() const SBE_NOEXCEPT { - return m_buffer + m_offset + 14; - } + SBE_NODISCARD const char *asset() const SBE_NOEXCEPT + { + return m_buffer + m_offset + 14; + } - SBE_NODISCARD char *asset() SBE_NOEXCEPT { return m_buffer + m_offset + 14; } + SBE_NODISCARD char *asset() SBE_NOEXCEPT + { + return m_buffer + m_offset + 14; + } - SBE_NODISCARD char asset(const std::uint64_t index) const { - if (index >= 6) { - throw std::runtime_error("index out of range for asset [E104]"); - } + SBE_NODISCARD char asset(const std::uint64_t index) const + { + if (index >= 6) + { + throw std::runtime_error("index out of range for asset [E104]"); + } - char val; - std::memcpy(&val, m_buffer + m_offset + 14 + (index * 1), sizeof(char)); - return (val); - } + char val; + std::memcpy(&val, m_buffer + m_offset + 14 + (index * 1), sizeof(char)); + return (val); + } - SecurityStatus30 &asset(const std::uint64_t index, const char value) { - if (index >= 6) { - throw std::runtime_error("index out of range for asset [E105]"); - } + SecurityStatus30 &asset(const std::uint64_t index, const char value) + { + if (index >= 6) + { + throw std::runtime_error("index out of range for asset [E105]"); + } - char val = (value); - std::memcpy(m_buffer + m_offset + 14 + (index * 1), &val, sizeof(char)); - return *this; - } + char val = (value); + std::memcpy(m_buffer + m_offset + 14 + (index * 1), &val, sizeof(char)); + return *this; + } - std::uint64_t getAsset(char *const dst, const std::uint64_t length) const { - if (length > 6) { - throw std::runtime_error("length too large for getAsset [E106]"); - } + std::uint64_t getAsset(char *const dst, const std::uint64_t length) const + { + if (length > 6) + { + throw std::runtime_error("length too large for getAsset [E106]"); + } - std::memcpy( - dst, m_buffer + m_offset + 14, - sizeof(char) * static_cast(length)); - return length; - } + std::memcpy(dst, m_buffer + m_offset + 14, sizeof(char) * static_cast(length)); + return length; + } - SecurityStatus30 &putAsset(const char *const src) SBE_NOEXCEPT { - std::memcpy(m_buffer + m_offset + 14, src, sizeof(char) * 6); - return *this; - } + SecurityStatus30 &putAsset(const char *const src) SBE_NOEXCEPT + { + std::memcpy(m_buffer + m_offset + 14, src, sizeof(char) * 6); + return *this; + } - std::string getAssetAsString() const { - const char *buffer = m_buffer + m_offset + 14; - size_t length = 0; + SBE_NODISCARD std::string getAssetAsString() const + { + const char *buffer = m_buffer + m_offset + 14; + 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 getAssetAsJsonEscapedString() { - std::ostringstream oss; - std::string s = getAssetAsString(); + std::string getAssetAsJsonEscapedString() + { + std::ostringstream oss; + std::string s = getAssetAsString(); - 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; + for (const auto c : s) + { + switch (c) + { + case '"': oss << "\\\""; break; + case '\\': oss << "\\\\"; break; + case '\b': oss << "\\b"; break; + case '\f': oss << "\\f"; break; + case '\n': oss << "\\n"; break; + case '\r': oss << "\\r"; break; + case '\t': oss << "\\t"; break; - default: - if ('\x00' <= *c && *c <= '\x1f') { - oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') - << (int)(*c); - } else { - oss << *c; + default: + if ('\x00' <= 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 getAssetAsStringView() const SBE_NOEXCEPT { - const char *buffer = m_buffer + m_offset + 14; - size_t length = 0; + #if __cplusplus >= 201703L + SBE_NODISCARD std::string_view getAssetAsStringView() const SBE_NOEXCEPT + { + const char *buffer = m_buffer + m_offset + 14; + 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 - SecurityStatus30 &putAsset(const std::string_view str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putAsset [E106]"); - } + #if __cplusplus >= 201703L + SecurityStatus30 &putAsset(const std::string_view str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putAsset [E106]"); + } - std::memcpy(m_buffer + m_offset + 14, str.data(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 14 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 14, str.data(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 14 + start] = 0; + } - return *this; - } -#else - SecurityStatus30 &putAsset(const std::string &str) { - const size_t srcLength = str.length(); - if (srcLength > 6) { - throw std::runtime_error("string too large for putAsset [E106]"); - } + return *this; + } + #else + SecurityStatus30 &putAsset(const std::string& str) + { + const size_t srcLength = str.length(); + if (srcLength > 6) + { + throw std::runtime_error("string too large for putAsset [E106]"); + } - std::memcpy(m_buffer + m_offset + 14, str.c_str(), srcLength); - for (size_t start = srcLength; start < 6; ++start) { - m_buffer[m_offset + 14 + start] = 0; - } + std::memcpy(m_buffer + m_offset + 14, str.c_str(), srcLength); + for (size_t start = srcLength; start < 6; ++start) + { + m_buffer[m_offset + 14 + 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 20; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 20; + } - 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 + 20, 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 + 20, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - SecurityStatus30 &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; - } + SecurityStatus30 &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 * - TradeDateMetaAttribute(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 *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; } + 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 static SBE_CONSTEXPR std::uint64_t tradeDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool tradeDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tradeDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tradeDateSinceVersion(); + return m_actingVersion >= tradeDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradeDateEncodingOffset() SBE_NOEXCEPT { - return 24; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradeDateEncodingOffset() SBE_NOEXCEPT + { + return 24; + } - static SBE_CONSTEXPR std::uint16_t tradeDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t tradeDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t tradeDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t tradeDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t tradeDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t tradeDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t tradeDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + 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 + 24, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t tradeDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } - SecurityStatus30 &tradeDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint16_t)); - return *this; - } + SecurityStatus30 &tradeDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::uint16_t)); + return *this; + } - SBE_NODISCARD static const char *MatchEventIndicatorMetaAttribute( - 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 *MatchEventIndicatorMetaAttribute(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 matchEventIndicatorId() SBE_NOEXCEPT { - return 5799; - } + static SBE_CONSTEXPR std::uint16_t matchEventIndicatorId() SBE_NOEXCEPT + { + return 5799; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - matchEventIndicatorSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t matchEventIndicatorSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool matchEventIndicatorInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= matchEventIndicatorSinceVersion(); + return m_actingVersion >= matchEventIndicatorSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingOffset() SBE_NOEXCEPT { - return 26; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingOffset() SBE_NOEXCEPT + { + return 26; + } - private: - MatchEventIndicator m_matchEventIndicator; +private: + MatchEventIndicator m_matchEventIndicator; - public: - SBE_NODISCARD MatchEventIndicator &matchEventIndicator() { - m_matchEventIndicator.wrap( - m_buffer, m_offset + 26, m_actingVersion, m_bufferLength); - return m_matchEventIndicator; - } +public: + SBE_NODISCARD MatchEventIndicator &matchEventIndicator() + { + m_matchEventIndicator.wrap(m_buffer, m_offset + 26, m_actingVersion, m_bufferLength); + return m_matchEventIndicator; + } - static SBE_CONSTEXPR std::size_t - matchEventIndicatorEncodingLength() SBE_NOEXCEPT { - return 1; - } + static SBE_CONSTEXPR std::size_t matchEventIndicatorEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD static const char *SecurityTradingStatusMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityTradingStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityTradingStatusId() SBE_NOEXCEPT { - return 326; - } + static SBE_CONSTEXPR std::uint16_t securityTradingStatusId() SBE_NOEXCEPT + { + return 326; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityTradingStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityTradingStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityTradingStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityTradingStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityTradingStatusSinceVersion(); + return m_actingVersion >= securityTradingStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityTradingStatusEncodingOffset() SBE_NOEXCEPT { - return 27; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityTradingStatusEncodingOffset() SBE_NOEXCEPT + { + return 27; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityTradingStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityTradingStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SecurityTradingStatus::Value - securityTradingStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 27, sizeof(std::uint8_t)); - return SecurityTradingStatus::get((val)); - } + SBE_NODISCARD SecurityTradingStatus::Value securityTradingStatus() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 27, sizeof(std::uint8_t)); + return SecurityTradingStatus::get((val)); + } - SecurityStatus30 &securityTradingStatus( - const SecurityTradingStatus::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 27, &val, sizeof(std::uint8_t)); - return *this; - } + SecurityStatus30 &securityTradingStatus(const SecurityTradingStatus::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 27, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - HaltReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *HaltReasonMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t haltReasonId() SBE_NOEXCEPT { - return 327; - } + static SBE_CONSTEXPR std::uint16_t haltReasonId() SBE_NOEXCEPT + { + return 327; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - haltReasonSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t haltReasonSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool haltReasonInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool haltReasonInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= haltReasonSinceVersion(); + return m_actingVersion >= haltReasonSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - haltReasonEncodingOffset() SBE_NOEXCEPT { - return 28; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t haltReasonEncodingOffset() SBE_NOEXCEPT + { + return 28; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - haltReasonEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t haltReasonEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD HaltReason::Value haltReason() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::uint8_t)); - return HaltReason::get((val)); - } + SBE_NODISCARD HaltReason::Value haltReason() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 28, sizeof(std::uint8_t)); + return HaltReason::get((val)); + } - SecurityStatus30 &haltReason(const HaltReason::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 28, &val, sizeof(std::uint8_t)); - return *this; - } + SecurityStatus30 &haltReason(const HaltReason::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 static const char *SecurityTradingEventMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *SecurityTradingEventMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t securityTradingEventId() SBE_NOEXCEPT { - return 1174; - } + static SBE_CONSTEXPR std::uint16_t securityTradingEventId() SBE_NOEXCEPT + { + return 1174; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - securityTradingEventSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t securityTradingEventSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool securityTradingEventInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool securityTradingEventInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= securityTradingEventSinceVersion(); + return m_actingVersion >= securityTradingEventSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityTradingEventEncodingOffset() SBE_NOEXCEPT { - return 29; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityTradingEventEncodingOffset() SBE_NOEXCEPT + { + return 29; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - securityTradingEventEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityTradingEventEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SecurityTradingEvent::Value - securityTradingEvent() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 29, sizeof(std::uint8_t)); - return SecurityTradingEvent::get((val)); - } + SBE_NODISCARD SecurityTradingEvent::Value securityTradingEvent() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 29, sizeof(std::uint8_t)); + return SecurityTradingEvent::get((val)); + } - SecurityStatus30 & - securityTradingEvent(const SecurityTradingEvent::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 29, &val, sizeof(std::uint8_t)); - return *this; - } + SecurityStatus30 &securityTradingEvent(const SecurityTradingEvent::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 29, &val, sizeof(std::uint8_t)); + return *this; + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, SecurityStatus30 _writer) { - SecurityStatus30 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "SecurityStatus30", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, SecurityStatus30 _writer) +{ + SecurityStatus30 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "SecurityStatus30", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); - builder << ", "; - builder << R"("SecurityGroup": )"; - builder << '"' << writer.getSecurityGroupAsJsonEscapedString().c_str() - << '"'; + builder << ", "; + builder << R"("SecurityGroup": )"; + builder << '"' << + writer.getSecurityGroupAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("Asset": )"; - builder << '"' << writer.getAssetAsJsonEscapedString().c_str() << '"'; + builder << ", "; + builder << R"("Asset": )"; + builder << '"' << + writer.getAssetAsJsonEscapedString().c_str() << '"'; - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); - builder << ", "; - builder << R"("TradeDate": )"; - builder << +writer.tradeDate(); + builder << ", "; + builder << R"("TradeDate": )"; + builder << +writer.tradeDate(); - builder << ", "; - builder << R"("MatchEventIndicator": )"; - builder << writer.matchEventIndicator(); + builder << ", "; + builder << R"("MatchEventIndicator": )"; + builder << writer.matchEventIndicator(); - builder << ", "; - builder << R"("SecurityTradingStatus": )"; - builder << '"' << writer.securityTradingStatus() << '"'; + builder << ", "; + builder << R"("SecurityTradingStatus": )"; + builder << '"' << writer.securityTradingStatus() << '"'; - builder << ", "; - builder << R"("HaltReason": )"; - builder << '"' << writer.haltReason() << '"'; + builder << ", "; + builder << R"("HaltReason": )"; + builder << '"' << writer.haltReason() << '"'; - builder << ", "; - builder << R"("SecurityTradingEvent": )"; - builder << '"' << writer.securityTradingEvent() << '"'; + builder << ", "; + builder << R"("SecurityTradingEvent": )"; + builder << '"' << writer.securityTradingEvent() << '"'; - builder << '}'; + builder << '}'; - return 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 +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/SecurityTradingEvent.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/SecurityTradingEvent.h index d00e9be4d..a47e189a2 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/SecurityTradingEvent.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/SecurityTradingEvent.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,66 +86,60 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class SecurityTradingEvent { - public: - enum Value { - NoEvent = (std::uint8_t)0, - NoCancel = (std::uint8_t)1, - ResetStatistics = (std::uint8_t)4, - ImpliedMatchingON = (std::uint8_t)5, - ImpliedMatchingOFF = (std::uint8_t)6, - NULL_VALUE = (std::uint8_t)255 - }; +class SecurityTradingEvent +{ +public: + enum Value + { + NoEvent = static_cast(0), + NoCancel = static_cast(1), + ResetStatistics = static_cast(4), + ImpliedMatchingON = static_cast(5), + ImpliedMatchingOFF = static_cast(6), + NULL_VALUE = static_cast(255) + }; - static SecurityTradingEvent::Value get(const std::uint8_t value) { - switch (value) { - case 0: - return NoEvent; - case 1: - return NoCancel; - case 4: - return ResetStatistics; - case 5: - return ImpliedMatchingON; - case 6: - return ImpliedMatchingOFF; - case 255: - return NULL_VALUE; - } + static SecurityTradingEvent::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(0): return NoEvent; + case static_cast(1): return NoCancel; + case static_cast(4): return ResetStatistics; + case static_cast(5): return ImpliedMatchingON; + case static_cast(6): return ImpliedMatchingOFF; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error( - "unknown value for enum SecurityTradingEvent [E103]"); - } + throw std::runtime_error("unknown value for enum SecurityTradingEvent [E103]"); + } - static const char *c_str(const SecurityTradingEvent::Value value) { - switch (value) { - case NoEvent: - return "NoEvent"; - case NoCancel: - return "NoCancel"; - case ResetStatistics: - return "ResetStatistics"; - case ImpliedMatchingON: - return "ImpliedMatchingON"; - case ImpliedMatchingOFF: - return "ImpliedMatchingOFF"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const SecurityTradingEvent::Value value) + { + switch (value) + { + case NoEvent: return "NoEvent"; + case NoCancel: return "NoCancel"; + case ResetStatistics: return "ResetStatistics"; + case ImpliedMatchingON: return "ImpliedMatchingON"; + case ImpliedMatchingOFF: return "ImpliedMatchingOFF"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum SecurityTradingEvent [E103]:"); - } + throw std::runtime_error("unknown value for enum SecurityTradingEvent [E103]:"); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &os, SecurityTradingEvent::Value m) { - return os << SecurityTradingEvent::c_str(m); - } + template + friend std::basic_ostream& operator << ( + std::basic_ostream& os, SecurityTradingEvent::Value m) + { + return os << SecurityTradingEvent::c_str(m); + } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/SecurityTradingStatus.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/SecurityTradingStatus.h index f1d8927c5..6d6353ed5 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/SecurityTradingStatus.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/SecurityTradingStatus.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,96 +86,78 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class SecurityTradingStatus { - public: - enum Value { - TradingHalt = (std::uint8_t)2, - Close = (std::uint8_t)4, - NewPriceIndication = (std::uint8_t)15, - ReadyToTrade = (std::uint8_t)17, - NotAvailableForTrading = (std::uint8_t)18, - UnknownorInvalid = (std::uint8_t)20, - PreOpen = (std::uint8_t)21, - PreCross = (std::uint8_t)24, - Cross = (std::uint8_t)25, - PostClose = (std::uint8_t)26, - NoChange = (std::uint8_t)103, - NULL_VALUE = (std::uint8_t)255 - }; +class SecurityTradingStatus +{ +public: + enum Value + { + TradingHalt = static_cast(2), + Close = static_cast(4), + NewPriceIndication = static_cast(15), + ReadyToTrade = static_cast(17), + NotAvailableForTrading = static_cast(18), + UnknownorInvalid = static_cast(20), + PreOpen = static_cast(21), + PreCross = static_cast(24), + Cross = static_cast(25), + PostClose = static_cast(26), + NoChange = static_cast(103), + NULL_VALUE = static_cast(255) + }; - static SecurityTradingStatus::Value get(const std::uint8_t value) { - switch (value) { - case 2: - return TradingHalt; - case 4: - return Close; - case 15: - return NewPriceIndication; - case 17: - return ReadyToTrade; - case 18: - return NotAvailableForTrading; - case 20: - return UnknownorInvalid; - case 21: - return PreOpen; - case 24: - return PreCross; - case 25: - return Cross; - case 26: - return PostClose; - case 103: - return NoChange; - case 255: - return NULL_VALUE; - } + static SecurityTradingStatus::Value get(const std::uint8_t value) + { + switch (value) + { + case static_cast(2): return TradingHalt; + case static_cast(4): return Close; + case static_cast(15): return NewPriceIndication; + case static_cast(17): return ReadyToTrade; + case static_cast(18): return NotAvailableForTrading; + case static_cast(20): return UnknownorInvalid; + case static_cast(21): return PreOpen; + case static_cast(24): return PreCross; + case static_cast(25): return Cross; + case static_cast(26): return PostClose; + case static_cast(103): return NoChange; + case static_cast(255): return NULL_VALUE; + } - throw std::runtime_error( - "unknown value for enum SecurityTradingStatus [E103]"); - } + throw std::runtime_error("unknown value for enum SecurityTradingStatus [E103]"); + } - static const char *c_str(const SecurityTradingStatus::Value value) { - switch (value) { - case TradingHalt: - return "TradingHalt"; - case Close: - return "Close"; - case NewPriceIndication: - return "NewPriceIndication"; - case ReadyToTrade: - return "ReadyToTrade"; - case NotAvailableForTrading: - return "NotAvailableForTrading"; - case UnknownorInvalid: - return "UnknownorInvalid"; - case PreOpen: - return "PreOpen"; - case PreCross: - return "PreCross"; - case Cross: - return "Cross"; - case PostClose: - return "PostClose"; - case NoChange: - return "NoChange"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const SecurityTradingStatus::Value value) + { + switch (value) + { + case TradingHalt: return "TradingHalt"; + case Close: return "Close"; + case NewPriceIndication: return "NewPriceIndication"; + case ReadyToTrade: return "ReadyToTrade"; + case NotAvailableForTrading: return "NotAvailableForTrading"; + case UnknownorInvalid: return "UnknownorInvalid"; + case PreOpen: return "PreOpen"; + case PreCross: return "PreCross"; + case Cross: return "Cross"; + case PostClose: return "PostClose"; + case NoChange: return "NoChange"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum SecurityTradingStatus [E103]:"); - } + throw std::runtime_error("unknown value for enum SecurityTradingStatus [E103]:"); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &os, SecurityTradingStatus::Value m) { - return os << SecurityTradingStatus::c_str(m); - } + template + friend std::basic_ostream& operator << ( + std::basic_ostream& os, SecurityTradingStatus::Value m) + { + return os << SecurityTradingStatus::c_str(m); + } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/SecurityUpdateAction.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/SecurityUpdateAction.h index 12a464c90..5df6b9acf 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/SecurityUpdateAction.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/SecurityUpdateAction.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,56 +86,54 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class SecurityUpdateAction { - public: - enum Value { - Add = (char)65, - Delete = (char)68, - Modify = (char)77, - NULL_VALUE = (char)0 - }; +class SecurityUpdateAction +{ +public: + enum Value + { + Add = static_cast(65), + Delete = static_cast(68), + Modify = static_cast(77), + NULL_VALUE = static_cast(0) + }; - static SecurityUpdateAction::Value get(const char value) { - switch (value) { - case 65: - return Add; - case 68: - return Delete; - case 77: - return Modify; - case 0: - return NULL_VALUE; - } + static SecurityUpdateAction::Value get(const char value) + { + switch (value) + { + case static_cast(65): return Add; + case static_cast(68): return Delete; + case static_cast(77): return Modify; + case static_cast(0): return NULL_VALUE; + } - throw std::runtime_error( - "unknown value for enum SecurityUpdateAction [E103]"); - } + throw std::runtime_error("unknown value for enum SecurityUpdateAction [E103]"); + } - static const char *c_str(const SecurityUpdateAction::Value value) { - switch (value) { - case Add: - return "Add"; - case Delete: - return "Delete"; - case Modify: - return "Modify"; - case NULL_VALUE: - return "NULL_VALUE"; - } + static const char *c_str(const SecurityUpdateAction::Value value) + { + switch (value) + { + case Add: return "Add"; + case Delete: return "Delete"; + case Modify: return "Modify"; + case NULL_VALUE: return "NULL_VALUE"; + } - throw std::runtime_error( - "unknown value for enum SecurityUpdateAction [E103]:"); - } + throw std::runtime_error("unknown value for enum SecurityUpdateAction [E103]:"); + } - template - friend std::basic_ostream &operator<<( - std::basic_ostream &os, SecurityUpdateAction::Value m) { - return os << SecurityUpdateAction::c_str(m); - } + template + friend std::basic_ostream& operator << ( + std::basic_ostream& os, SecurityUpdateAction::Value m) + { + return os << SecurityUpdateAction::c_str(m); + } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/SettlPriceType.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/SettlPriceType.h index b1bdc4362..6b020092a 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/SettlPriceType.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/SettlPriceType.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,311 +86,363 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() + namespace mdp3 { -class SettlPriceType { - private: - char *m_buffer = nullptr; - std::uint64_t m_bufferLength = 0; - std::uint64_t m_offset = 0; - std::uint64_t m_actingVersion = 0; +class SettlPriceType +{ +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; + }; - SettlPriceType() = default; + SettlPriceType() = default; - SettlPriceType( - 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]"); - } - } + SettlPriceType( + 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]"); + } + } - SettlPriceType( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingVersion) - : SettlPriceType(buffer, 0, bufferLength, actingVersion) {} + SettlPriceType( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingVersion) : + SettlPriceType(buffer, 0, bufferLength, actingVersion) + { + } - SettlPriceType(char *buffer, const std::uint64_t bufferLength) - : SettlPriceType(buffer, 0, bufferLength, sbeSchemaVersion()) {} + SettlPriceType( + char *buffer, + const std::uint64_t bufferLength) : + SettlPriceType(buffer, 0, bufferLength, sbeSchemaVersion()) + { + } - SettlPriceType &wrap( - char *buffer, - const std::uint64_t offset, - const std::uint64_t actingVersion, - const std::uint64_t bufferLength) { - return *this = - SettlPriceType(buffer, offset, bufferLength, actingVersion); - } + SettlPriceType &wrap( + char *buffer, + const std::uint64_t offset, + const std::uint64_t actingVersion, + const std::uint64_t bufferLength) + { + return *this = SettlPriceType(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)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - SettlPriceType &clear() { - std::uint8_t zero = 0; - std::memcpy(m_buffer + m_offset, &zero, sizeof(std::uint8_t)); - return *this; - } + SettlPriceType &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; + } - SettlPriceType &rawValue(std::uint8_t value) { - std::memcpy(m_buffer + m_offset, &value, sizeof(std::uint8_t)); - return *this; - } + SettlPriceType &rawValue(std::uint8_t value) + { + std::memcpy(m_buffer + m_offset, &value, sizeof(std::uint8_t)); + return *this; + } - static bool finalDaily(const std::uint8_t bits) { - return (bits & (1u << 0u)) != 0; - } + static bool finalDaily(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 0u)) != 0; + } - static std::uint8_t finalDaily(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 0u)) - : static_cast(bits & ~(1u << 0u)); - } + static std::uint8_t finalDaily(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 finalDaily() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 0u)) != 0; - } + SBE_NODISCARD bool finalDaily() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 0u)) != 0; + } - SettlPriceType &finalDaily(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; - } + SettlPriceType &finalDaily(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 actual(const std::uint8_t bits) { - return (bits & (1u << 1u)) != 0; - } + static bool actual(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 1u)) != 0; + } - static std::uint8_t actual(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 1u)) - : static_cast(bits & ~(1u << 1u)); - } + static std::uint8_t actual(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 actual() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 1u)) != 0; - } + SBE_NODISCARD bool actual() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 1u)) != 0; + } - SettlPriceType &actual(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; - } + SettlPriceType &actual(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 rounded(const std::uint8_t bits) { - return (bits & (1u << 2u)) != 0; - } + static bool rounded(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 2u)) != 0; + } - static std::uint8_t rounded(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 2u)) - : static_cast(bits & ~(1u << 2u)); - } + static std::uint8_t rounded(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 rounded() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 2u)) != 0; - } + SBE_NODISCARD bool rounded() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 2u)) != 0; + } - SettlPriceType &rounded(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; - } + SettlPriceType &rounded(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 intraday(const std::uint8_t bits) { - return (bits & (1u << 3u)) != 0; - } + static bool intraday(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 3u)) != 0; + } - static std::uint8_t intraday(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 3u)) - : static_cast(bits & ~(1u << 3u)); - } + static std::uint8_t intraday(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 intraday() const { - if (m_actingVersion < 4) { - return false; - } + SBE_NODISCARD bool intraday() const + { + if (m_actingVersion < 4) + { + return false; + } - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 3u)) != 0; - } + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 3u)) != 0; + } - SettlPriceType &intraday(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; - } + SettlPriceType &intraday(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 reservedBits(const std::uint8_t bits) { - return (bits & (1u << 4u)) != 0; - } + static bool reservedBits(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 4u)) != 0; + } - static std::uint8_t reservedBits(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 4u)) - : static_cast(bits & ~(1u << 4u)); - } + static std::uint8_t reservedBits(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 reservedBits() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 4u)) != 0; - } + SBE_NODISCARD bool reservedBits() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 4u)) != 0; + } - SettlPriceType &reservedBits(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; - } + SettlPriceType &reservedBits(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 nullValue(const std::uint8_t bits) { - return (bits & (1u << 7u)) != 0; - } + static bool nullValue(const std::uint8_t bits) + { + return (bits & (static_cast(1) << 7u)) != 0; + } - static std::uint8_t nullValue(const std::uint8_t bits, const bool value) { - return value ? static_cast(bits | (1u << 7u)) - : static_cast(bits & ~(1u << 7u)); - } + static std::uint8_t nullValue(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 nullValue() const { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); - return ((val) & (1u << 7u)) != 0; - } + SBE_NODISCARD bool nullValue() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset, sizeof(std::uint8_t)); + return ((val) & (static_cast(1) << 7u)) != 0; + } - SettlPriceType &nullValue(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; - } + SettlPriceType &nullValue(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, SettlPriceType writer) { - builder << '['; - bool atLeastOne = false; - if (writer.finalDaily()) { - builder << R"("finalDaily")"; - atLeastOne = true; - } - if (writer.actual()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("actual")"; - atLeastOne = true; - } - if (writer.rounded()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("rounded")"; - atLeastOne = true; - } - if (writer.intraday()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("intraday")"; - atLeastOne = true; - } - if (writer.reservedBits()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("reservedBits")"; - atLeastOne = true; - } - if (writer.nullValue()) { - if (atLeastOne) { - builder << ","; - } - builder << R"("nullValue")"; - } - builder << ']'; - return builder; - } + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, SettlPriceType writer) + { + builder << '['; + bool atLeastOne = false; + if (writer.finalDaily()) + { + builder << R"("finalDaily")"; + atLeastOne = true; + } + if (writer.actual()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("actual")"; + atLeastOne = true; + } + if (writer.rounded()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("rounded")"; + atLeastOne = true; + } + if (writer.intraday()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("intraday")"; + atLeastOne = true; + } + if (writer.reservedBits()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("reservedBits")"; + atLeastOne = true; + } + if (writer.nullValue()) + { + if (atLeastOne) + { + builder << ","; + } + builder << R"("nullValue")"; + } + builder << ']'; + return builder; + } }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/SnapshotFullRefresh38.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/SnapshotFullRefresh38.h index 9d17820e3..c5edee28c 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/SnapshotFullRefresh38.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/SnapshotFullRefresh38.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,1597 +86,1786 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class SnapshotFullRefresh38 { - 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 SnapshotFullRefresh38 +{ +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; } + 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(59); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(38); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - SnapshotFullRefresh38() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - SnapshotFullRefresh38( - 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; - SnapshotFullRefresh38(char *buffer, const std::uint64_t bufferLength) - : SnapshotFullRefresh38( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + SnapshotFullRefresh38() = default; - SnapshotFullRefresh38( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : SnapshotFullRefresh38( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + SnapshotFullRefresh38( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)59; - } + SnapshotFullRefresh38(char *buffer, const std::uint64_t bufferLength) : + SnapshotFullRefresh38(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)38; - } + SnapshotFullRefresh38( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + SnapshotFullRefresh38(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(59); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "W"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(38); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SnapshotFullRefresh38 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = SnapshotFullRefresh38( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - SnapshotFullRefresh38 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "W"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = SnapshotFullRefresh38( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + SnapshotFullRefresh38 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = SnapshotFullRefresh38(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - SnapshotFullRefresh38 &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 = SnapshotFullRefresh38( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + SnapshotFullRefresh38 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = SnapshotFullRefresh38( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + SnapshotFullRefresh38 &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 = SnapshotFullRefresh38(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + SnapshotFullRefresh38 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char *LastMsgSeqNumProcessedMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "SeqNum"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t lastMsgSeqNumProcessedId() SBE_NOEXCEPT { - return 369; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastMsgSeqNumProcessedSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool lastMsgSeqNumProcessedInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *LastMsgSeqNumProcessedMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "SeqNum"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lastMsgSeqNumProcessedId() SBE_NOEXCEPT + { + return 369; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastMsgSeqNumProcessedSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lastMsgSeqNumProcessedInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastMsgSeqNumProcessedSinceVersion(); + return m_actingVersion >= lastMsgSeqNumProcessedSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastMsgSeqNumProcessedEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastMsgSeqNumProcessedEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t - lastMsgSeqNumProcessedNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t lastMsgSeqNumProcessedNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t - lastMsgSeqNumProcessedMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t lastMsgSeqNumProcessedMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t - lastMsgSeqNumProcessedMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t lastMsgSeqNumProcessedMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t - lastMsgSeqNumProcessedEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t lastMsgSeqNumProcessedEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t lastMsgSeqNumProcessed() 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 lastMsgSeqNumProcessed() 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); + } - SnapshotFullRefresh38 & - lastMsgSeqNumProcessed(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; - } + SnapshotFullRefresh38 &lastMsgSeqNumProcessed(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 * - TotNumReportsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TotNumReportsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT { - return 911; - } + static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT + { + return 911; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totNumReportsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t totNumReportsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= totNumReportsSinceVersion(); + return m_actingVersion >= totNumReportsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totNumReportsEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t totNumReportsEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t totNumReports() 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); - } + SBE_NODISCARD std::uint32_t totNumReports() 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); + } - SnapshotFullRefresh38 & - totNumReports(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; - } + SnapshotFullRefresh38 &totNumReports(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 * - 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 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - 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 + 8, 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 + 8, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - SnapshotFullRefresh38 &securityID(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; - } + SnapshotFullRefresh38 &securityID(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 * - RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "SeqNum"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "SeqNum"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT { return 83; } + static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT + { + return 83; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - rptSeqSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t rptSeqSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= rptSeqSinceVersion(); + return m_actingVersion >= rptSeqSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - rptSeqEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t rptSeqEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t rptSeq() 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 rptSeq() 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); + } - SnapshotFullRefresh38 &rptSeq(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; - } + SnapshotFullRefresh38 &rptSeq(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 * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - 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 "UTCTimestamp"; + 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 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - 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 + 16, 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 + 16, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - SnapshotFullRefresh38 &transactTime(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; - } + SnapshotFullRefresh38 &transactTime(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 * - LastUpdateTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LastUpdateTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t lastUpdateTimeId() SBE_NOEXCEPT { - return 779; - } + static SBE_CONSTEXPR std::uint16_t lastUpdateTimeId() SBE_NOEXCEPT + { + return 779; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastUpdateTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastUpdateTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lastUpdateTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lastUpdateTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastUpdateTimeSinceVersion(); + return m_actingVersion >= lastUpdateTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastUpdateTimeEncodingOffset() SBE_NOEXCEPT { - return 24; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastUpdateTimeEncodingOffset() SBE_NOEXCEPT + { + return 24; + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - lastUpdateTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t lastUpdateTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t lastUpdateTime() 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 lastUpdateTime() 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); + } - SnapshotFullRefresh38 & - lastUpdateTime(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; - } + SnapshotFullRefresh38 &lastUpdateTime(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 * - TradeDateMetaAttribute(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 *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; } + 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 static SBE_CONSTEXPR std::uint64_t tradeDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool tradeDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tradeDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tradeDateSinceVersion(); + return m_actingVersion >= tradeDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradeDateEncodingOffset() SBE_NOEXCEPT { - return 32; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradeDateEncodingOffset() SBE_NOEXCEPT + { + return 32; + } - static SBE_CONSTEXPR std::uint16_t tradeDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t tradeDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t tradeDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t tradeDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t tradeDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t tradeDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t tradeDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + 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 + 32, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t tradeDate() 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); + } - SnapshotFullRefresh38 &tradeDate(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; - } + SnapshotFullRefresh38 &tradeDate(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 *MDSecurityTradingStatusMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MDSecurityTradingStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mDSecurityTradingStatusId() SBE_NOEXCEPT { - return 1682; - } + static SBE_CONSTEXPR std::uint16_t mDSecurityTradingStatusId() SBE_NOEXCEPT + { + return 1682; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDSecurityTradingStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDSecurityTradingStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mDSecurityTradingStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mDSecurityTradingStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDSecurityTradingStatusSinceVersion(); + return m_actingVersion >= mDSecurityTradingStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDSecurityTradingStatusEncodingOffset() SBE_NOEXCEPT { - return 34; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDSecurityTradingStatusEncodingOffset() SBE_NOEXCEPT + { + return 34; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDSecurityTradingStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDSecurityTradingStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SecurityTradingStatus::Value - mDSecurityTradingStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 34, sizeof(std::uint8_t)); - return SecurityTradingStatus::get((val)); - } + SBE_NODISCARD SecurityTradingStatus::Value mDSecurityTradingStatus() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 34, sizeof(std::uint8_t)); + return SecurityTradingStatus::get((val)); + } - SnapshotFullRefresh38 &mDSecurityTradingStatus( - const SecurityTradingStatus::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 34, &val, sizeof(std::uint8_t)); - return *this; - } + SnapshotFullRefresh38 &mDSecurityTradingStatus(const SecurityTradingStatus::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 34, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - HighLimitPriceMetaAttribute(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 *HighLimitPriceMetaAttribute(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 highLimitPriceId() SBE_NOEXCEPT { - return 1149; - } + static SBE_CONSTEXPR std::uint16_t highLimitPriceId() SBE_NOEXCEPT + { + return 1149; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - highLimitPriceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t highLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= highLimitPriceSinceVersion(); + return m_actingVersion >= highLimitPriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - highLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 35; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t highLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 35; + } - private: - PRICENULL m_highLimitPrice; +private: + PRICENULL m_highLimitPrice; - public: - SBE_NODISCARD PRICENULL &highLimitPrice() { - m_highLimitPrice.wrap( - m_buffer, m_offset + 35, m_actingVersion, m_bufferLength); - return m_highLimitPrice; - } +public: + SBE_NODISCARD PRICENULL &highLimitPrice() + { + m_highLimitPrice.wrap(m_buffer, m_offset + 35, m_actingVersion, m_bufferLength); + return m_highLimitPrice; + } - SBE_NODISCARD static const char * - LowLimitPriceMetaAttribute(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 *LowLimitPriceMetaAttribute(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 lowLimitPriceId() SBE_NOEXCEPT { - return 1148; - } + static SBE_CONSTEXPR std::uint16_t lowLimitPriceId() SBE_NOEXCEPT + { + return 1148; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lowLimitPriceSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lowLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lowLimitPriceSinceVersion(); + return m_actingVersion >= lowLimitPriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lowLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 43; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lowLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 43; + } - private: - PRICENULL m_lowLimitPrice; +private: + PRICENULL m_lowLimitPrice; - public: - SBE_NODISCARD PRICENULL &lowLimitPrice() { - m_lowLimitPrice.wrap( - m_buffer, m_offset + 43, m_actingVersion, m_bufferLength); - return m_lowLimitPrice; - } +public: + SBE_NODISCARD PRICENULL &lowLimitPrice() + { + m_lowLimitPrice.wrap(m_buffer, m_offset + 43, m_actingVersion, m_bufferLength); + return m_lowLimitPrice; + } - SBE_NODISCARD static const char *MaxPriceVariationMetaAttribute( - 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 *MaxPriceVariationMetaAttribute(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 maxPriceVariationId() SBE_NOEXCEPT { - return 1143; - } + static SBE_CONSTEXPR std::uint16_t maxPriceVariationId() SBE_NOEXCEPT + { + return 1143; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - maxPriceVariationSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maxPriceVariationSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool maxPriceVariationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool maxPriceVariationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= maxPriceVariationSinceVersion(); + return m_actingVersion >= maxPriceVariationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maxPriceVariationEncodingOffset() SBE_NOEXCEPT { - return 51; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maxPriceVariationEncodingOffset() SBE_NOEXCEPT + { + return 51; + } - private: - PRICENULL m_maxPriceVariation; +private: + PRICENULL m_maxPriceVariation; - public: - SBE_NODISCARD PRICENULL &maxPriceVariation() { - m_maxPriceVariation.wrap( - m_buffer, m_offset + 51, m_actingVersion, m_bufferLength); - return m_maxPriceVariation; - } +public: + SBE_NODISCARD PRICENULL &maxPriceVariation() + { + m_maxPriceVariation.wrap(m_buffer, m_offset + 51, m_actingVersion, m_bufferLength); + return m_maxPriceVariation; + } - class NoMDEntries { + class NoMDEntries + { 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 NoMDEntries &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(static_cast(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 *MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT + { + return 270; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICENULL m_mDEntryPx; + +public: + SBE_NODISCARD PRICENULL &mDEntryPx() + { + m_mDEntryPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_mDEntryPx; + } + + SBE_NODISCARD static const char *MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT + { + return 271; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntrySizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntrySizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t mDEntrySize() 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); + } + + NoMDEntries &mDEntrySize(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 *NumberOfOrdersMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t numberOfOrdersId() SBE_NOEXCEPT + { + return 346; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t numberOfOrdersSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool numberOfOrdersInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= numberOfOrdersSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t numberOfOrdersEncodingOffset() SBE_NOEXCEPT + { + return 12; + } + + static SBE_CONSTEXPR std::int32_t numberOfOrdersNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t numberOfOrdersMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t numberOfOrdersMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t numberOfOrdersEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t numberOfOrders() 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); + } + + NoMDEntries &numberOfOrders(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 *MDPriceLevelMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDPriceLevelId() SBE_NOEXCEPT + { + return 1023; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDPriceLevelSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDPriceLevelInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDPriceLevelSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDPriceLevelEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + + static SBE_CONSTEXPR std::int8_t mDPriceLevelNullValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::int8_t mDPriceLevelMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t mDPriceLevelMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t mDPriceLevelEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::int8_t mDPriceLevel() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::int8_t)); + return (val); + } + + NoMDEntries &mDPriceLevel(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::int8_t)); + return *this; + } + + SBE_NODISCARD static const char *TradingReferenceDateMetaAttribute(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 tradingReferenceDateId() SBE_NOEXCEPT + { + return 5796; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingReferenceDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= tradingReferenceDateSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingOffset() SBE_NOEXCEPT + { + return 17; + } + + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t tradingReferenceDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + NoMDEntries &tradingReferenceDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *OpenCloseSettlFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t openCloseSettlFlagId() SBE_NOEXCEPT + { + return 286; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t openCloseSettlFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool openCloseSettlFlagInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= openCloseSettlFlagSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t openCloseSettlFlagEncodingOffset() SBE_NOEXCEPT + { + return 19; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t openCloseSettlFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD OpenCloseSettlFlag::Value openCloseSettlFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 19, sizeof(std::uint8_t)); + return OpenCloseSettlFlag::get((val)); + } + + NoMDEntries &openCloseSettlFlag(const OpenCloseSettlFlag::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 static const char *SettlPriceTypeMetaAttribute(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 settlPriceTypeId() SBE_NOEXCEPT + { + return 731; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t settlPriceTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= settlPriceTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + private: + SettlPriceType m_settlPriceType; + + public: + SBE_NODISCARD SettlPriceType &settlPriceType() + { + m_settlPriceType.wrap(m_buffer, m_offset + 20, m_actingVersion, m_bufferLength); + return m_settlPriceType; + } + + static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD static const char *MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT + { + return 269; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingOffset() SBE_NOEXCEPT + { + return 21; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDEntryType::Value mDEntryType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 21, sizeof(char)); + return MDEntryType::get((val)); + } + + NoMDEntries &mDEntryType(const MDEntryType::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 21, &val, sizeof(char)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDEntries writer) + { + builder << '{'; + builder << R"("MDEntryPx": )"; + builder << writer.mDEntryPx(); + + builder << ", "; + builder << R"("MDEntrySize": )"; + builder << +writer.mDEntrySize(); + + builder << ", "; + builder << R"("NumberOfOrders": )"; + builder << +writer.numberOfOrders(); + + builder << ", "; + builder << R"("MDPriceLevel": )"; + builder << +writer.mDPriceLevel(); + + builder << ", "; + builder << R"("TradingReferenceDate": )"; + builder << +writer.tradingReferenceDate(); + + builder << ", "; + builder << R"("OpenCloseSettlFlag": )"; + builder << '"' << writer.openCloseSettlFlag() << '"'; + + builder << ", "; + builder << R"("SettlPriceType": )"; + builder << writer.settlPriceType(); + + builder << ", "; + builder << R"("MDEntryType": )"; + builder << '"' << writer.mDEntryType() << '"'; + + 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: + NoMDEntries m_noMDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 22; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDEntriesId() SBE_NOEXCEPT + { + return 268; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDEntries &noMDEntries() + { + m_noMDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDEntries &noMDEntriesCount(const std::uint8_t count) + { + m_noMDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDEntriesSinceVersion() 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 NoMDEntries &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 * - MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT { - return 270; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDEntryPxSinceVersion(); + return m_actingVersion >= noMDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - private: - PRICENULL m_mDEntryPx; - - public: - SBE_NODISCARD PRICENULL &mDEntryPx() { - m_mDEntryPx.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_mDEntryPx; - } - - SBE_NODISCARD static const char * - MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT { - return 271; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntrySizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntrySizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t mDEntrySize() 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); - } - - NoMDEntries &mDEntrySize(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 *NumberOfOrdersMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t numberOfOrdersId() SBE_NOEXCEPT { - return 346; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - numberOfOrdersSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool numberOfOrdersInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= numberOfOrdersSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - numberOfOrdersEncodingOffset() SBE_NOEXCEPT { - return 12; - } - - static SBE_CONSTEXPR std::int32_t numberOfOrdersNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t numberOfOrdersMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t numberOfOrdersMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - numberOfOrdersEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t numberOfOrders() 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); - } - - NoMDEntries &numberOfOrders(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 *MDPriceLevelMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDPriceLevelId() SBE_NOEXCEPT { - return 1023; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDPriceLevelSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDPriceLevelInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDPriceLevelSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDPriceLevelEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - static SBE_CONSTEXPR std::int8_t mDPriceLevelNullValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::int8_t mDPriceLevelMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t mDPriceLevelMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t - mDPriceLevelEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::int8_t mDPriceLevel() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::int8_t)); - return (val); - } - - NoMDEntries &mDPriceLevel(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::int8_t)); - return *this; - } - - SBE_NODISCARD static const char *TradingReferenceDateMetaAttribute( - 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 tradingReferenceDateId() SBE_NOEXCEPT { - return 5796; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingReferenceDateSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= tradingReferenceDateSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingOffset() SBE_NOEXCEPT { - return 17; - } - - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t tradingReferenceDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - NoMDEntries & - tradingReferenceDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char *OpenCloseSettlFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t openCloseSettlFlagId() SBE_NOEXCEPT { - return 286; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - openCloseSettlFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool openCloseSettlFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= openCloseSettlFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - openCloseSettlFlagEncodingOffset() SBE_NOEXCEPT { - return 19; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - openCloseSettlFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD OpenCloseSettlFlag::Value - openCloseSettlFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 19, sizeof(std::uint8_t)); - return OpenCloseSettlFlag::get((val)); - } - - NoMDEntries & - openCloseSettlFlag(const OpenCloseSettlFlag::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 static const char *SettlPriceTypeMetaAttribute( - 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 settlPriceTypeId() SBE_NOEXCEPT { - return 731; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - settlPriceTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= settlPriceTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingOffset() SBE_NOEXCEPT { - return 20; - } - - private: - SettlPriceType m_settlPriceType; - - public: - SBE_NODISCARD SettlPriceType &settlPriceType() { - m_settlPriceType.wrap( - m_buffer, m_offset + 20, m_actingVersion, m_bufferLength); - return m_settlPriceType; - } - - static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD static const char * - MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT { - return 269; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingOffset() SBE_NOEXCEPT { - return 21; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDEntryType::Value mDEntryType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 21, sizeof(char)); - return MDEntryType::get((val)); - } - - NoMDEntries &mDEntryType(const MDEntryType::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 21, &val, sizeof(char)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDEntries writer) { - builder << '{'; - builder << R"("MDEntryPx": )"; - builder << writer.mDEntryPx(); - - builder << ", "; - builder << R"("MDEntrySize": )"; - builder << +writer.mDEntrySize(); - - builder << ", "; - builder << R"("NumberOfOrders": )"; - builder << +writer.numberOfOrders(); - - builder << ", "; - builder << R"("MDPriceLevel": )"; - builder << +writer.mDPriceLevel(); - - builder << ", "; - builder << R"("TradingReferenceDate": )"; - builder << +writer.tradingReferenceDate(); - - builder << ", "; - builder << R"("OpenCloseSettlFlag": )"; - builder << '"' << writer.openCloseSettlFlag() << '"'; - - builder << ", "; - builder << R"("SettlPriceType": )"; - builder << writer.settlPriceType(); - - builder << ", "; - builder << R"("MDEntryType": )"; - builder << '"' << writer.mDEntryType() << '"'; - - builder << '}'; - - return builder; - } - }; - - private: - NoMDEntries m_noMDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDEntriesId() SBE_NOEXCEPT { - return 268; - } - - SBE_NODISCARD inline NoMDEntries &noMDEntries() { - m_noMDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - NoMDEntries &noMDEntriesCount(const std::uint8_t count) { - m_noMDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - SnapshotFullRefresh38 _writer) { - SnapshotFullRefresh38 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "SnapshotFullRefresh38", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("LastMsgSeqNumProcessed": )"; - builder << +writer.lastMsgSeqNumProcessed(); - - builder << ", "; - builder << R"("TotNumReports": )"; - builder << +writer.totNumReports(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("RptSeq": )"; - builder << +writer.rptSeq(); - - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("LastUpdateTime": )"; - builder << +writer.lastUpdateTime(); - - builder << ", "; - builder << R"("TradeDate": )"; - builder << +writer.tradeDate(); - - builder << ", "; - builder << R"("MDSecurityTradingStatus": )"; - builder << '"' << writer.mDSecurityTradingStatus() << '"'; - - builder << ", "; - builder << R"("HighLimitPrice": )"; - builder << writer.highLimitPrice(); - - builder << ", "; - builder << R"("LowLimitPrice": )"; - builder << writer.lowLimitPrice(); - - builder << ", "; - builder << R"("MaxPriceVariation": )"; - builder << writer.maxPriceVariation(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDEntries": [)"; - writer.noMDEntries().forEach([&](NoMDEntries &noMDEntries) { - if (atLeastOne) { - builder << ", "; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, SnapshotFullRefresh38 _writer) +{ + SnapshotFullRefresh38 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "SnapshotFullRefresh38", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("LastMsgSeqNumProcessed": )"; + builder << +writer.lastMsgSeqNumProcessed(); + + builder << ", "; + builder << R"("TotNumReports": )"; + builder << +writer.totNumReports(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("RptSeq": )"; + builder << +writer.rptSeq(); + + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("LastUpdateTime": )"; + builder << +writer.lastUpdateTime(); + + builder << ", "; + builder << R"("TradeDate": )"; + builder << +writer.tradeDate(); + + builder << ", "; + builder << R"("MDSecurityTradingStatus": )"; + builder << '"' << writer.mDSecurityTradingStatus() << '"'; + + builder << ", "; + builder << R"("HighLimitPrice": )"; + builder << writer.highLimitPrice(); + + builder << ", "; + builder << R"("LowLimitPrice": )"; + builder << writer.lowLimitPrice(); + + builder << ", "; + builder << R"("MaxPriceVariation": )"; + builder << writer.maxPriceVariation(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDEntries": [)"; + writer.noMDEntries().forEach([&](NoMDEntries& noMDEntries) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDEntries; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noMDEntries().forEach([](NoMDEntries e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t noMDEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoMDEntries::sbeHeaderSize(); + if (noMDEntriesLength > 254LL) + { + throw std::runtime_error("noMDEntriesLength outside of allowed range [E110]"); + } + length += noMDEntriesLength *NoMDEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/SnapshotFullRefresh52.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/SnapshotFullRefresh52.h index a9fd6eed9..c90549d38 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/SnapshotFullRefresh52.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/SnapshotFullRefresh52.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,1597 +86,1786 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class SnapshotFullRefresh52 { - 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 SnapshotFullRefresh52 +{ +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; } + 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(59); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(52); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - SnapshotFullRefresh52() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - SnapshotFullRefresh52( - 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; - SnapshotFullRefresh52(char *buffer, const std::uint64_t bufferLength) - : SnapshotFullRefresh52( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + SnapshotFullRefresh52() = default; - SnapshotFullRefresh52( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : SnapshotFullRefresh52( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + SnapshotFullRefresh52( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)59; - } + SnapshotFullRefresh52(char *buffer, const std::uint64_t bufferLength) : + SnapshotFullRefresh52(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)52; - } + SnapshotFullRefresh52( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + SnapshotFullRefresh52(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(59); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "W"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(52); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SnapshotFullRefresh52 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = SnapshotFullRefresh52( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - SnapshotFullRefresh52 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "W"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = SnapshotFullRefresh52( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + SnapshotFullRefresh52 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = SnapshotFullRefresh52(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - SnapshotFullRefresh52 &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 = SnapshotFullRefresh52( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + SnapshotFullRefresh52 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = SnapshotFullRefresh52( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + SnapshotFullRefresh52 &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 = SnapshotFullRefresh52(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + SnapshotFullRefresh52 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char *LastMsgSeqNumProcessedMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "SeqNum"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t lastMsgSeqNumProcessedId() SBE_NOEXCEPT { - return 369; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastMsgSeqNumProcessedSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool lastMsgSeqNumProcessedInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *LastMsgSeqNumProcessedMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "SeqNum"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lastMsgSeqNumProcessedId() SBE_NOEXCEPT + { + return 369; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastMsgSeqNumProcessedSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lastMsgSeqNumProcessedInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastMsgSeqNumProcessedSinceVersion(); + return m_actingVersion >= lastMsgSeqNumProcessedSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastMsgSeqNumProcessedEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastMsgSeqNumProcessedEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t - lastMsgSeqNumProcessedNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t lastMsgSeqNumProcessedNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t - lastMsgSeqNumProcessedMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t lastMsgSeqNumProcessedMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t - lastMsgSeqNumProcessedMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t lastMsgSeqNumProcessedMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t - lastMsgSeqNumProcessedEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t lastMsgSeqNumProcessedEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t lastMsgSeqNumProcessed() 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 lastMsgSeqNumProcessed() 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); + } - SnapshotFullRefresh52 & - lastMsgSeqNumProcessed(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; - } + SnapshotFullRefresh52 &lastMsgSeqNumProcessed(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 * - TotNumReportsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TotNumReportsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT { - return 911; - } + static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT + { + return 911; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totNumReportsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t totNumReportsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= totNumReportsSinceVersion(); + return m_actingVersion >= totNumReportsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totNumReportsEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t totNumReportsEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t totNumReports() 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); - } + SBE_NODISCARD std::uint32_t totNumReports() 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); + } - SnapshotFullRefresh52 & - totNumReports(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; - } + SnapshotFullRefresh52 &totNumReports(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 * - 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 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - 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 + 8, 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 + 8, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - SnapshotFullRefresh52 &securityID(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; - } + SnapshotFullRefresh52 &securityID(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 * - RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *RptSeqMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT { return 83; } + static SBE_CONSTEXPR std::uint16_t rptSeqId() SBE_NOEXCEPT + { + return 83; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - rptSeqSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t rptSeqSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool rptSeqInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= rptSeqSinceVersion(); + return m_actingVersion >= rptSeqSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - rptSeqEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t rptSeqEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t rptSeqNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t rptSeqMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t rptSeqMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t rptSeqEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t rptSeq() 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 rptSeq() 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); + } - SnapshotFullRefresh52 &rptSeq(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; - } + SnapshotFullRefresh52 &rptSeq(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 * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - 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 "UTCTimestamp"; + 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 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - 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 + 16, 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 + 16, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - SnapshotFullRefresh52 &transactTime(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; - } + SnapshotFullRefresh52 &transactTime(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 * - LastUpdateTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *LastUpdateTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "UTCTimestamp"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t lastUpdateTimeId() SBE_NOEXCEPT { - return 779; - } + static SBE_CONSTEXPR std::uint16_t lastUpdateTimeId() SBE_NOEXCEPT + { + return 779; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastUpdateTimeSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastUpdateTimeSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool lastUpdateTimeInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lastUpdateTimeInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastUpdateTimeSinceVersion(); + return m_actingVersion >= lastUpdateTimeSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastUpdateTimeEncodingOffset() SBE_NOEXCEPT { - return 24; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastUpdateTimeEncodingOffset() SBE_NOEXCEPT + { + return 24; + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT64; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT64; + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMinValue() SBE_NOEXCEPT { - return 0x0L; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } - static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } + static SBE_CONSTEXPR std::uint64_t lastUpdateTimeMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } - static SBE_CONSTEXPR std::size_t - lastUpdateTimeEncodingLength() SBE_NOEXCEPT { - return 8; - } + static SBE_CONSTEXPR std::size_t lastUpdateTimeEncodingLength() SBE_NOEXCEPT + { + return 8; + } - SBE_NODISCARD std::uint64_t lastUpdateTime() 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 lastUpdateTime() 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); + } - SnapshotFullRefresh52 & - lastUpdateTime(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; - } + SnapshotFullRefresh52 &lastUpdateTime(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 * - TradeDateMetaAttribute(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 *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; } + 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 static SBE_CONSTEXPR std::uint64_t tradeDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool tradeDateInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool tradeDateInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= tradeDateSinceVersion(); + return m_actingVersion >= tradeDateSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradeDateEncodingOffset() SBE_NOEXCEPT { - return 32; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradeDateEncodingOffset() SBE_NOEXCEPT + { + return 32; + } - static SBE_CONSTEXPR std::uint16_t tradeDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } + static SBE_CONSTEXPR std::uint16_t tradeDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } - static SBE_CONSTEXPR std::uint16_t tradeDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } + static SBE_CONSTEXPR std::uint16_t tradeDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } - static SBE_CONSTEXPR std::uint16_t tradeDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } + static SBE_CONSTEXPR std::uint16_t tradeDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } - static SBE_CONSTEXPR std::size_t tradeDateEncodingLength() SBE_NOEXCEPT { - return 2; - } + 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 + 32, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } + SBE_NODISCARD std::uint16_t tradeDate() 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); + } - SnapshotFullRefresh52 &tradeDate(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; - } + SnapshotFullRefresh52 &tradeDate(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 *MDSecurityTradingStatusMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *MDSecurityTradingStatusMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t mDSecurityTradingStatusId() SBE_NOEXCEPT { - return 1682; - } + static SBE_CONSTEXPR std::uint16_t mDSecurityTradingStatusId() SBE_NOEXCEPT + { + return 1682; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDSecurityTradingStatusSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDSecurityTradingStatusSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool mDSecurityTradingStatusInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool mDSecurityTradingStatusInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDSecurityTradingStatusSinceVersion(); + return m_actingVersion >= mDSecurityTradingStatusSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDSecurityTradingStatusEncodingOffset() SBE_NOEXCEPT { - return 34; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDSecurityTradingStatusEncodingOffset() SBE_NOEXCEPT + { + return 34; + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDSecurityTradingStatusEncodingLength() SBE_NOEXCEPT { - return 1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDSecurityTradingStatusEncodingLength() SBE_NOEXCEPT + { + return 1; + } - SBE_NODISCARD SecurityTradingStatus::Value - mDSecurityTradingStatus() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 34, sizeof(std::uint8_t)); - return SecurityTradingStatus::get((val)); - } + SBE_NODISCARD SecurityTradingStatus::Value mDSecurityTradingStatus() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 34, sizeof(std::uint8_t)); + return SecurityTradingStatus::get((val)); + } - SnapshotFullRefresh52 &mDSecurityTradingStatus( - const SecurityTradingStatus::Value value) SBE_NOEXCEPT { - std::uint8_t val = (value); - std::memcpy(m_buffer + m_offset + 34, &val, sizeof(std::uint8_t)); - return *this; - } + SnapshotFullRefresh52 &mDSecurityTradingStatus(const SecurityTradingStatus::Value value) SBE_NOEXCEPT + { + std::uint8_t val = (value); + std::memcpy(m_buffer + m_offset + 34, &val, sizeof(std::uint8_t)); + return *this; + } - SBE_NODISCARD static const char * - HighLimitPriceMetaAttribute(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 *HighLimitPriceMetaAttribute(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 highLimitPriceId() SBE_NOEXCEPT { - return 1149; - } + static SBE_CONSTEXPR std::uint16_t highLimitPriceId() SBE_NOEXCEPT + { + return 1149; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - highLimitPriceSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t highLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool highLimitPriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= highLimitPriceSinceVersion(); + return m_actingVersion >= highLimitPriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - highLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 35; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t highLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 35; + } - private: - PRICENULL9 m_highLimitPrice; +private: + PRICENULL9 m_highLimitPrice; - public: - SBE_NODISCARD PRICENULL9 &highLimitPrice() { - m_highLimitPrice.wrap( - m_buffer, m_offset + 35, m_actingVersion, m_bufferLength); - return m_highLimitPrice; - } +public: + SBE_NODISCARD PRICENULL9 &highLimitPrice() + { + m_highLimitPrice.wrap(m_buffer, m_offset + 35, m_actingVersion, m_bufferLength); + return m_highLimitPrice; + } - SBE_NODISCARD static const char * - LowLimitPriceMetaAttribute(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 *LowLimitPriceMetaAttribute(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 lowLimitPriceId() SBE_NOEXCEPT { - return 1148; - } + static SBE_CONSTEXPR std::uint16_t lowLimitPriceId() SBE_NOEXCEPT + { + return 1148; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lowLimitPriceSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lowLimitPriceSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool lowLimitPriceInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lowLimitPriceSinceVersion(); + return m_actingVersion >= lowLimitPriceSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lowLimitPriceEncodingOffset() SBE_NOEXCEPT { - return 43; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lowLimitPriceEncodingOffset() SBE_NOEXCEPT + { + return 43; + } - private: - PRICENULL9 m_lowLimitPrice; +private: + PRICENULL9 m_lowLimitPrice; - public: - SBE_NODISCARD PRICENULL9 &lowLimitPrice() { - m_lowLimitPrice.wrap( - m_buffer, m_offset + 43, m_actingVersion, m_bufferLength); - return m_lowLimitPrice; - } +public: + SBE_NODISCARD PRICENULL9 &lowLimitPrice() + { + m_lowLimitPrice.wrap(m_buffer, m_offset + 43, m_actingVersion, m_bufferLength); + return m_lowLimitPrice; + } - SBE_NODISCARD static const char *MaxPriceVariationMetaAttribute( - 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 *MaxPriceVariationMetaAttribute(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 maxPriceVariationId() SBE_NOEXCEPT { - return 1143; - } + static SBE_CONSTEXPR std::uint16_t maxPriceVariationId() SBE_NOEXCEPT + { + return 1143; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - maxPriceVariationSinceVersion() SBE_NOEXCEPT { - return 9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t maxPriceVariationSinceVersion() SBE_NOEXCEPT + { + return 9; + } - SBE_NODISCARD bool maxPriceVariationInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool maxPriceVariationInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= maxPriceVariationSinceVersion(); + return m_actingVersion >= maxPriceVariationSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - maxPriceVariationEncodingOffset() SBE_NOEXCEPT { - return 51; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t maxPriceVariationEncodingOffset() SBE_NOEXCEPT + { + return 51; + } - private: - PRICENULL9 m_maxPriceVariation; +private: + PRICENULL9 m_maxPriceVariation; - public: - SBE_NODISCARD PRICENULL9 &maxPriceVariation() { - m_maxPriceVariation.wrap( - m_buffer, m_offset + 51, m_actingVersion, m_bufferLength); - return m_maxPriceVariation; - } +public: + SBE_NODISCARD PRICENULL9 &maxPriceVariation() + { + m_maxPriceVariation.wrap(m_buffer, m_offset + 51, m_actingVersion, m_bufferLength); + return m_maxPriceVariation; + } - class NoMDEntries { + class NoMDEntries + { 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 NoMDEntries &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(static_cast(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 *MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT + { + return 270; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryPxSinceVersion() SBE_NOEXCEPT + { + return 9; + } + + SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryPxEncodingOffset() SBE_NOEXCEPT + { + return 0; + } + +private: + PRICENULL9 m_mDEntryPx; + +public: + SBE_NODISCARD PRICENULL9 &mDEntryPx() + { + m_mDEntryPx.wrap(m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); + return m_mDEntryPx; + } + + SBE_NODISCARD static const char *MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT + { + return 271; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntrySizeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntrySizeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t mDEntrySizeEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t mDEntrySize() 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); + } + + NoMDEntries &mDEntrySize(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 *NumberOfOrdersMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t numberOfOrdersId() SBE_NOEXCEPT + { + return 346; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t numberOfOrdersSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool numberOfOrdersInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= numberOfOrdersSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t numberOfOrdersEncodingOffset() SBE_NOEXCEPT + { + return 12; + } + + static SBE_CONSTEXPR std::int32_t numberOfOrdersNullValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::int32_t numberOfOrdersMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t numberOfOrdersMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t numberOfOrdersEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t numberOfOrders() 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); + } + + NoMDEntries &numberOfOrders(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 *MDPriceLevelMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDPriceLevelId() SBE_NOEXCEPT + { + return 1023; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDPriceLevelSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDPriceLevelInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDPriceLevelSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDPriceLevelEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + + static SBE_CONSTEXPR std::int8_t mDPriceLevelNullValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::int8_t mDPriceLevelMinValue() SBE_NOEXCEPT + { + return static_cast(-127); + } + + static SBE_CONSTEXPR std::int8_t mDPriceLevelMaxValue() SBE_NOEXCEPT + { + return static_cast(127); + } + + static SBE_CONSTEXPR std::size_t mDPriceLevelEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD std::int8_t mDPriceLevel() const SBE_NOEXCEPT + { + std::int8_t val; + std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::int8_t)); + return (val); + } + + NoMDEntries &mDPriceLevel(const std::int8_t value) SBE_NOEXCEPT + { + std::int8_t val = (value); + std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::int8_t)); + return *this; + } + + SBE_NODISCARD static const char *TradingReferenceDateMetaAttribute(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 tradingReferenceDateId() SBE_NOEXCEPT + { + return 5796; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t tradingReferenceDateSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= tradingReferenceDateSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingOffset() SBE_NOEXCEPT + { + return 17; + } + + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateNullValue() SBE_NOEXCEPT + { + return static_cast(65535); + } + + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMinValue() SBE_NOEXCEPT + { + return static_cast(0); + } + + static SBE_CONSTEXPR std::uint16_t tradingReferenceDateMaxValue() SBE_NOEXCEPT + { + return static_cast(65534); + } + + static SBE_CONSTEXPR std::size_t tradingReferenceDateEncodingLength() SBE_NOEXCEPT + { + return 2; + } + + SBE_NODISCARD std::uint16_t tradingReferenceDate() const SBE_NOEXCEPT + { + std::uint16_t val; + std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint16_t)); + return SBE_LITTLE_ENDIAN_ENCODE_16(val); + } + + NoMDEntries &tradingReferenceDate(const std::uint16_t value) SBE_NOEXCEPT + { + std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); + std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint16_t)); + return *this; + } + + SBE_NODISCARD static const char *OpenCloseSettlFlagMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t openCloseSettlFlagId() SBE_NOEXCEPT + { + return 286; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t openCloseSettlFlagSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool openCloseSettlFlagInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= openCloseSettlFlagSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t openCloseSettlFlagEncodingOffset() SBE_NOEXCEPT + { + return 19; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t openCloseSettlFlagEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD OpenCloseSettlFlag::Value openCloseSettlFlag() const + { + std::uint8_t val; + std::memcpy(&val, m_buffer + m_offset + 19, sizeof(std::uint8_t)); + return OpenCloseSettlFlag::get((val)); + } + + NoMDEntries &openCloseSettlFlag(const OpenCloseSettlFlag::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 static const char *SettlPriceTypeMetaAttribute(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 settlPriceTypeId() SBE_NOEXCEPT + { + return 731; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t settlPriceTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= settlPriceTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingOffset() SBE_NOEXCEPT + { + return 20; + } + + private: + SettlPriceType m_settlPriceType; + + public: + SBE_NODISCARD SettlPriceType &settlPriceType() + { + m_settlPriceType.wrap(m_buffer, m_offset + 20, m_actingVersion, m_bufferLength); + return m_settlPriceType; + } + + static SBE_CONSTEXPR std::size_t settlPriceTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD static const char *MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT + { + return 269; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingOffset() SBE_NOEXCEPT + { + return 21; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDEntryType::Value mDEntryType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 21, sizeof(char)); + return MDEntryType::get((val)); + } + + NoMDEntries &mDEntryType(const MDEntryType::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 21, &val, sizeof(char)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDEntries writer) + { + builder << '{'; + builder << R"("MDEntryPx": )"; + builder << writer.mDEntryPx(); + + builder << ", "; + builder << R"("MDEntrySize": )"; + builder << +writer.mDEntrySize(); + + builder << ", "; + builder << R"("NumberOfOrders": )"; + builder << +writer.numberOfOrders(); + + builder << ", "; + builder << R"("MDPriceLevel": )"; + builder << +writer.mDPriceLevel(); + + builder << ", "; + builder << R"("TradingReferenceDate": )"; + builder << +writer.tradingReferenceDate(); + + builder << ", "; + builder << R"("OpenCloseSettlFlag": )"; + builder << '"' << writer.openCloseSettlFlag() << '"'; + + builder << ", "; + builder << R"("SettlPriceType": )"; + builder << writer.settlPriceType(); + + builder << ", "; + builder << R"("MDEntryType": )"; + builder << '"' << writer.mDEntryType() << '"'; + + 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: + NoMDEntries m_noMDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 22; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDEntriesId() SBE_NOEXCEPT + { + return 268; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDEntries &noMDEntries() + { + m_noMDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDEntries &noMDEntriesCount(const std::uint8_t count) + { + m_noMDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDEntriesSinceVersion() 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 NoMDEntries &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 * - MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT { - return 270; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryPxSinceVersion() SBE_NOEXCEPT { - return 9; - } - - SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= mDEntryPxSinceVersion(); + return m_actingVersion >= noMDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryPxEncodingOffset() SBE_NOEXCEPT { - return 0; - } - - private: - PRICENULL9 m_mDEntryPx; - - public: - SBE_NODISCARD PRICENULL9 &mDEntryPx() { - m_mDEntryPx.wrap( - m_buffer, m_offset + 0, m_actingVersion, m_bufferLength); - return m_mDEntryPx; - } - - SBE_NODISCARD static const char * - MDEntrySizeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDEntrySizeId() SBE_NOEXCEPT { - return 271; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntrySizeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntrySizeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntrySizeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDEntrySizeMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - mDEntrySizeEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t mDEntrySize() 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); - } - - NoMDEntries &mDEntrySize(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 *NumberOfOrdersMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t numberOfOrdersId() SBE_NOEXCEPT { - return 346; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - numberOfOrdersSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool numberOfOrdersInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= numberOfOrdersSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - numberOfOrdersEncodingOffset() SBE_NOEXCEPT { - return 12; - } - - static SBE_CONSTEXPR std::int32_t numberOfOrdersNullValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::int32_t numberOfOrdersMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t numberOfOrdersMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - numberOfOrdersEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t numberOfOrders() 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); - } - - NoMDEntries &numberOfOrders(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 *MDPriceLevelMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDPriceLevelId() SBE_NOEXCEPT { - return 1023; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDPriceLevelSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDPriceLevelInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDPriceLevelSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDPriceLevelEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - static SBE_CONSTEXPR std::int8_t mDPriceLevelNullValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::int8_t mDPriceLevelMinValue() SBE_NOEXCEPT { - return (std::int8_t)-127; - } - - static SBE_CONSTEXPR std::int8_t mDPriceLevelMaxValue() SBE_NOEXCEPT { - return (std::int8_t)127; - } - - static SBE_CONSTEXPR std::size_t - mDPriceLevelEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD std::int8_t mDPriceLevel() const SBE_NOEXCEPT { - std::int8_t val; - std::memcpy(&val, m_buffer + m_offset + 16, sizeof(std::int8_t)); - return (val); - } - - NoMDEntries &mDPriceLevel(const std::int8_t value) SBE_NOEXCEPT { - std::int8_t val = (value); - std::memcpy(m_buffer + m_offset + 16, &val, sizeof(std::int8_t)); - return *this; - } - - SBE_NODISCARD static const char *TradingReferenceDateMetaAttribute( - 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 tradingReferenceDateId() SBE_NOEXCEPT { - return 5796; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - tradingReferenceDateSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool tradingReferenceDateInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= tradingReferenceDateSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingOffset() SBE_NOEXCEPT { - return 17; - } - - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateNullValue() SBE_NOEXCEPT { - return (std::uint16_t)65535; - } - - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMinValue() SBE_NOEXCEPT { - return (std::uint16_t)0; - } - - static SBE_CONSTEXPR std::uint16_t - tradingReferenceDateMaxValue() SBE_NOEXCEPT { - return (std::uint16_t)65534; - } - - static SBE_CONSTEXPR std::size_t - tradingReferenceDateEncodingLength() SBE_NOEXCEPT { - return 2; - } - - SBE_NODISCARD std::uint16_t tradingReferenceDate() const SBE_NOEXCEPT { - std::uint16_t val; - std::memcpy(&val, m_buffer + m_offset + 17, sizeof(std::uint16_t)); - return SBE_LITTLE_ENDIAN_ENCODE_16(val); - } - - NoMDEntries & - tradingReferenceDate(const std::uint16_t value) SBE_NOEXCEPT { - std::uint16_t val = SBE_LITTLE_ENDIAN_ENCODE_16(value); - std::memcpy(m_buffer + m_offset + 17, &val, sizeof(std::uint16_t)); - return *this; - } - - SBE_NODISCARD static const char *OpenCloseSettlFlagMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t openCloseSettlFlagId() SBE_NOEXCEPT { - return 286; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - openCloseSettlFlagSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool openCloseSettlFlagInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= openCloseSettlFlagSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - openCloseSettlFlagEncodingOffset() SBE_NOEXCEPT { - return 19; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - openCloseSettlFlagEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD OpenCloseSettlFlag::Value - openCloseSettlFlag() const SBE_NOEXCEPT { - std::uint8_t val; - std::memcpy(&val, m_buffer + m_offset + 19, sizeof(std::uint8_t)); - return OpenCloseSettlFlag::get((val)); - } - - NoMDEntries & - openCloseSettlFlag(const OpenCloseSettlFlag::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 static const char *SettlPriceTypeMetaAttribute( - 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 settlPriceTypeId() SBE_NOEXCEPT { - return 731; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - settlPriceTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool settlPriceTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= settlPriceTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingOffset() SBE_NOEXCEPT { - return 20; - } - - private: - SettlPriceType m_settlPriceType; - - public: - SBE_NODISCARD SettlPriceType &settlPriceType() { - m_settlPriceType.wrap( - m_buffer, m_offset + 20, m_actingVersion, m_bufferLength); - return m_settlPriceType; - } - - static SBE_CONSTEXPR std::size_t - settlPriceTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD static const char * - MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT { - return 269; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingOffset() SBE_NOEXCEPT { - return 21; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDEntryType::Value mDEntryType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 21, sizeof(char)); - return MDEntryType::get((val)); - } - - NoMDEntries &mDEntryType(const MDEntryType::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 21, &val, sizeof(char)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDEntries writer) { - builder << '{'; - builder << R"("MDEntryPx": )"; - builder << writer.mDEntryPx(); - - builder << ", "; - builder << R"("MDEntrySize": )"; - builder << +writer.mDEntrySize(); - - builder << ", "; - builder << R"("NumberOfOrders": )"; - builder << +writer.numberOfOrders(); - - builder << ", "; - builder << R"("MDPriceLevel": )"; - builder << +writer.mDPriceLevel(); - - builder << ", "; - builder << R"("TradingReferenceDate": )"; - builder << +writer.tradingReferenceDate(); - - builder << ", "; - builder << R"("OpenCloseSettlFlag": )"; - builder << '"' << writer.openCloseSettlFlag() << '"'; - - builder << ", "; - builder << R"("SettlPriceType": )"; - builder << writer.settlPriceType(); - - builder << ", "; - builder << R"("MDEntryType": )"; - builder << '"' << writer.mDEntryType() << '"'; - - builder << '}'; - - return builder; - } - }; - - private: - NoMDEntries m_noMDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDEntriesId() SBE_NOEXCEPT { - return 268; - } - - SBE_NODISCARD inline NoMDEntries &noMDEntries() { - m_noMDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - NoMDEntries &noMDEntriesCount(const std::uint8_t count) { - m_noMDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - SnapshotFullRefresh52 _writer) { - SnapshotFullRefresh52 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "SnapshotFullRefresh52", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("LastMsgSeqNumProcessed": )"; - builder << +writer.lastMsgSeqNumProcessed(); - - builder << ", "; - builder << R"("TotNumReports": )"; - builder << +writer.totNumReports(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("RptSeq": )"; - builder << +writer.rptSeq(); - - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - builder << R"("LastUpdateTime": )"; - builder << +writer.lastUpdateTime(); - - builder << ", "; - builder << R"("TradeDate": )"; - builder << +writer.tradeDate(); - - builder << ", "; - builder << R"("MDSecurityTradingStatus": )"; - builder << '"' << writer.mDSecurityTradingStatus() << '"'; - - builder << ", "; - builder << R"("HighLimitPrice": )"; - builder << writer.highLimitPrice(); - - builder << ", "; - builder << R"("LowLimitPrice": )"; - builder << writer.lowLimitPrice(); - - builder << ", "; - builder << R"("MaxPriceVariation": )"; - builder << writer.maxPriceVariation(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDEntries": [)"; - writer.noMDEntries().forEach([&](NoMDEntries &noMDEntries) { - if (atLeastOne) { - builder << ", "; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, SnapshotFullRefresh52 _writer) +{ + SnapshotFullRefresh52 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "SnapshotFullRefresh52", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("LastMsgSeqNumProcessed": )"; + builder << +writer.lastMsgSeqNumProcessed(); + + builder << ", "; + builder << R"("TotNumReports": )"; + builder << +writer.totNumReports(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("RptSeq": )"; + builder << +writer.rptSeq(); + + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + builder << R"("LastUpdateTime": )"; + builder << +writer.lastUpdateTime(); + + builder << ", "; + builder << R"("TradeDate": )"; + builder << +writer.tradeDate(); + + builder << ", "; + builder << R"("MDSecurityTradingStatus": )"; + builder << '"' << writer.mDSecurityTradingStatus() << '"'; + + builder << ", "; + builder << R"("HighLimitPrice": )"; + builder << writer.highLimitPrice(); + + builder << ", "; + builder << R"("LowLimitPrice": )"; + builder << writer.lowLimitPrice(); + + builder << ", "; + builder << R"("MaxPriceVariation": )"; + builder << writer.maxPriceVariation(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDEntries": [)"; + writer.noMDEntries().forEach([&](NoMDEntries& noMDEntries) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDEntries; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noMDEntries().forEach([](NoMDEntries e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t noMDEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoMDEntries::sbeHeaderSize(); + if (noMDEntriesLength > 254LL) + { + throw std::runtime_error("noMDEntriesLength outside of allowed range [E110]"); + } + length += noMDEntriesLength *NoMDEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/SnapshotFullRefreshOrderBook44.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/SnapshotFullRefreshOrderBook44.h index 34c0a724b..14b4ace6b 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/SnapshotFullRefreshOrderBook44.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/SnapshotFullRefreshOrderBook44.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,1137 +86,1312 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class SnapshotFullRefreshOrderBook44 { - 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 SnapshotFullRefreshOrderBook44 +{ +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; } + 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(28); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(44); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - SnapshotFullRefreshOrderBook44() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - SnapshotFullRefreshOrderBook44( - 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; - SnapshotFullRefreshOrderBook44( - char *buffer, const std::uint64_t bufferLength) - : SnapshotFullRefreshOrderBook44( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + SnapshotFullRefreshOrderBook44() = default; - SnapshotFullRefreshOrderBook44( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : SnapshotFullRefreshOrderBook44( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + SnapshotFullRefreshOrderBook44( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)28; - } + SnapshotFullRefreshOrderBook44(char *buffer, const std::uint64_t bufferLength) : + SnapshotFullRefreshOrderBook44(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)44; - } + SnapshotFullRefreshOrderBook44( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + SnapshotFullRefreshOrderBook44(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(28); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "W"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(44); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SnapshotFullRefreshOrderBook44 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = SnapshotFullRefreshOrderBook44( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - SnapshotFullRefreshOrderBook44 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "W"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = SnapshotFullRefreshOrderBook44( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + SnapshotFullRefreshOrderBook44 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = SnapshotFullRefreshOrderBook44(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - SnapshotFullRefreshOrderBook44 &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 = SnapshotFullRefreshOrderBook44( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + SnapshotFullRefreshOrderBook44 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = SnapshotFullRefreshOrderBook44( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + SnapshotFullRefreshOrderBook44 &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 = SnapshotFullRefreshOrderBook44(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + SnapshotFullRefreshOrderBook44 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char *LastMsgSeqNumProcessedMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "SeqNum"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t lastMsgSeqNumProcessedId() SBE_NOEXCEPT { - return 369; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastMsgSeqNumProcessedSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool lastMsgSeqNumProcessedInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *LastMsgSeqNumProcessedMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "SeqNum"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lastMsgSeqNumProcessedId() SBE_NOEXCEPT + { + return 369; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastMsgSeqNumProcessedSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lastMsgSeqNumProcessedInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastMsgSeqNumProcessedSinceVersion(); + return m_actingVersion >= lastMsgSeqNumProcessedSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastMsgSeqNumProcessedEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastMsgSeqNumProcessedEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t - lastMsgSeqNumProcessedNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t lastMsgSeqNumProcessedNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t - lastMsgSeqNumProcessedMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t lastMsgSeqNumProcessedMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t - lastMsgSeqNumProcessedMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t lastMsgSeqNumProcessedMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t - lastMsgSeqNumProcessedEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t lastMsgSeqNumProcessedEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t lastMsgSeqNumProcessed() 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 lastMsgSeqNumProcessed() 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); + } - SnapshotFullRefreshOrderBook44 & - lastMsgSeqNumProcessed(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; - } + SnapshotFullRefreshOrderBook44 &lastMsgSeqNumProcessed(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 * - TotNumReportsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TotNumReportsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT { - return 911; - } + static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT + { + return 911; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totNumReportsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t totNumReportsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= totNumReportsSinceVersion(); + return m_actingVersion >= totNumReportsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totNumReportsEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t totNumReportsEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t totNumReports() 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); - } + SBE_NODISCARD std::uint32_t totNumReports() 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); + } - SnapshotFullRefreshOrderBook44 & - totNumReports(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; - } + SnapshotFullRefreshOrderBook44 &totNumReports(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 * - SecurityIDMetaAttribute(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 *SecurityIDMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "String"; + 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 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - 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 + 8, 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 + 8, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - SnapshotFullRefreshOrderBook44 & - securityID(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; - } + SnapshotFullRefreshOrderBook44 &securityID(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 * - NoChunksMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *NoChunksMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t noChunksId() SBE_NOEXCEPT { - return 37709; - } + static SBE_CONSTEXPR std::uint16_t noChunksId() SBE_NOEXCEPT + { + return 37709; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noChunksSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noChunksSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool noChunksInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noChunksInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noChunksSinceVersion(); + return m_actingVersion >= noChunksSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - noChunksEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t noChunksEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR std::uint32_t noChunksNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t noChunksNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t noChunksMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t noChunksMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t noChunksMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t noChunksMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t noChunksEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t noChunksEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t noChunks() 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 noChunks() 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); + } - SnapshotFullRefreshOrderBook44 & - noChunks(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; - } + SnapshotFullRefreshOrderBook44 &noChunks(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 * - CurrentChunkMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CurrentChunkMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t currentChunkId() SBE_NOEXCEPT { - return 37710; - } + static SBE_CONSTEXPR std::uint16_t currentChunkId() SBE_NOEXCEPT + { + return 37710; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - currentChunkSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t currentChunkSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool currentChunkInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool currentChunkInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= currentChunkSinceVersion(); + return m_actingVersion >= currentChunkSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - currentChunkEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t currentChunkEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - static SBE_CONSTEXPR std::uint32_t currentChunkNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t currentChunkNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t currentChunkMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t currentChunkMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t currentChunkMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t currentChunkMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t currentChunkEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t currentChunkEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t currentChunk() 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 currentChunk() 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); + } - SnapshotFullRefreshOrderBook44 & - currentChunk(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; - } + SnapshotFullRefreshOrderBook44 ¤tChunk(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 * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - 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 "UTCTimestamp"; + 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 20; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 20; + } - 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 + 20, 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 + 20, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - SnapshotFullRefreshOrderBook44 & - transactTime(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; - } + SnapshotFullRefreshOrderBook44 &transactTime(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; + } - class NoMDEntries { + class NoMDEntries + { 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(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::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 29; + } + + 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 NoMDEntries &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(static_cast(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 *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 0; + } + + 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoMDEntries &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 *MDOrderPriorityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDOrderPriorityId() SBE_NOEXCEPT + { + return 37707; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDOrderPrioritySinceVersion() SBE_NOEXCEPT + { + return 7; + } + + SBE_NODISCARD bool mDOrderPriorityInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDOrderPrioritySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDOrderPriorityEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t mDOrderPriorityNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + static SBE_CONSTEXPR std::uint64_t mDOrderPriorityMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t mDOrderPriorityMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t mDOrderPriorityEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t mDOrderPriority() const SBE_NOEXCEPT + { + if (m_actingVersion < 7) + { + return UINT64_C(0xffffffffffffffff); + } + + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoMDEntries &mDOrderPriority(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 *MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT + { + return 270; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryPxSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryPxEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + +private: + PRICE m_mDEntryPx; + +public: + SBE_NODISCARD PRICE &mDEntryPx() + { + m_mDEntryPx.wrap(m_buffer, m_offset + 16, m_actingVersion, m_bufferLength); + return m_mDEntryPx; + } + + SBE_NODISCARD static const char *MDDisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDDisplayQtyId() SBE_NOEXCEPT + { + return 37706; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDDisplayQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDDisplayQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDDisplayQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDDisplayQtyEncodingOffset() SBE_NOEXCEPT + { + return 24; + } + + static SBE_CONSTEXPR std::int32_t mDDisplayQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t mDDisplayQtyMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDDisplayQtyMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t mDDisplayQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t mDDisplayQty() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &mDDisplayQty(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT + { + return 269; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingOffset() SBE_NOEXCEPT + { + return 28; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDEntryTypeBook::Value mDEntryType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 28, sizeof(char)); + return MDEntryTypeBook::get((val)); + } + + NoMDEntries &mDEntryType(const MDEntryTypeBook::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 28, &val, sizeof(char)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDEntries writer) + { + builder << '{'; + builder << R"("OrderID": )"; + builder << +writer.orderID(); + + builder << ", "; + builder << R"("MDOrderPriority": )"; + builder << +writer.mDOrderPriority(); + + builder << ", "; + builder << R"("MDEntryPx": )"; + builder << writer.mDEntryPx(); + + builder << ", "; + builder << R"("MDDisplayQty": )"; + builder << +writer.mDDisplayQty(); + + builder << ", "; + builder << R"("MDEntryType": )"; + builder << '"' << writer.mDEntryType() << '"'; + + 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: + NoMDEntries m_noMDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 29; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDEntriesId() SBE_NOEXCEPT + { + return 268; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDEntries &noMDEntries() + { + m_noMDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDEntries &noMDEntriesCount(const std::uint8_t count) + { + m_noMDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDEntriesSinceVersion() 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 NoMDEntries &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 * - 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 { + SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= noMDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - 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 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 + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoMDEntries &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 *MDOrderPriorityMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDOrderPriorityId() SBE_NOEXCEPT { - return 37707; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDOrderPrioritySinceVersion() SBE_NOEXCEPT { - return 7; - } - - SBE_NODISCARD bool mDOrderPriorityInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDOrderPrioritySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDOrderPriorityEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::uint64_t - mDOrderPriorityNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } - - static SBE_CONSTEXPR std::uint64_t - mDOrderPriorityMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - mDOrderPriorityMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - mDOrderPriorityEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t mDOrderPriority() const SBE_NOEXCEPT { - if (m_actingVersion < 7) { - return 0xffffffffffffffffL; - } - - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoMDEntries &mDOrderPriority(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 * - MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT { - return 270; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryPxSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryPxSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryPxEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - private: - PRICE m_mDEntryPx; - - public: - SBE_NODISCARD PRICE &mDEntryPx() { - m_mDEntryPx.wrap( - m_buffer, m_offset + 16, m_actingVersion, m_bufferLength); - return m_mDEntryPx; - } - - SBE_NODISCARD static const char *MDDisplayQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDDisplayQtyId() SBE_NOEXCEPT { - return 37706; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDDisplayQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDDisplayQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDDisplayQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDDisplayQtyEncodingOffset() SBE_NOEXCEPT { - return 24; - } - - static SBE_CONSTEXPR std::int32_t mDDisplayQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t mDDisplayQtyMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDDisplayQtyMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - mDDisplayQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t mDDisplayQty() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoMDEntries &mDDisplayQty(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char * - MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT { - return 269; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingOffset() SBE_NOEXCEPT { - return 28; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDEntryTypeBook::Value mDEntryType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 28, sizeof(char)); - return MDEntryTypeBook::get((val)); - } - - NoMDEntries & - mDEntryType(const MDEntryTypeBook::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 28, &val, sizeof(char)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDEntries writer) { - builder << '{'; - builder << R"("OrderID": )"; - builder << +writer.orderID(); - - builder << ", "; - builder << R"("MDOrderPriority": )"; - builder << +writer.mDOrderPriority(); - - builder << ", "; - builder << R"("MDEntryPx": )"; - builder << writer.mDEntryPx(); - - builder << ", "; - builder << R"("MDDisplayQty": )"; - builder << +writer.mDDisplayQty(); - - builder << ", "; - builder << R"("MDEntryType": )"; - builder << '"' << writer.mDEntryType() << '"'; - - builder << '}'; - - return builder; - } - }; - - private: - NoMDEntries m_noMDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDEntriesId() SBE_NOEXCEPT { - return 268; - } - - SBE_NODISCARD inline NoMDEntries &noMDEntries() { - m_noMDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - NoMDEntries &noMDEntriesCount(const std::uint8_t count) { - m_noMDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - SnapshotFullRefreshOrderBook44 _writer) { - SnapshotFullRefreshOrderBook44 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "SnapshotFullRefreshOrderBook44", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("LastMsgSeqNumProcessed": )"; - builder << +writer.lastMsgSeqNumProcessed(); - - builder << ", "; - builder << R"("TotNumReports": )"; - builder << +writer.totNumReports(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("NoChunks": )"; - builder << +writer.noChunks(); - - builder << ", "; - builder << R"("CurrentChunk": )"; - builder << +writer.currentChunk(); - - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDEntries": [)"; - writer.noMDEntries().forEach([&](NoMDEntries &noMDEntries) { - if (atLeastOne) { - builder << ", "; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, SnapshotFullRefreshOrderBook44 _writer) +{ + SnapshotFullRefreshOrderBook44 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "SnapshotFullRefreshOrderBook44", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("LastMsgSeqNumProcessed": )"; + builder << +writer.lastMsgSeqNumProcessed(); + + builder << ", "; + builder << R"("TotNumReports": )"; + builder << +writer.totNumReports(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("NoChunks": )"; + builder << +writer.noChunks(); + + builder << ", "; + builder << R"("CurrentChunk": )"; + builder << +writer.currentChunk(); + + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDEntries": [)"; + writer.noMDEntries().forEach([&](NoMDEntries& noMDEntries) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDEntries; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noMDEntries().forEach([](NoMDEntries e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t noMDEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoMDEntries::sbeHeaderSize(); + if (noMDEntriesLength > 254LL) + { + throw std::runtime_error("noMDEntriesLength outside of allowed range [E110]"); + } + length += noMDEntriesLength *NoMDEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/market_data/gen/src/SnapshotFullRefreshOrderBook53.h b/src/server/sparkd/cmds/spartan/market_data/gen/src/SnapshotFullRefreshOrderBook53.h index cc47cfabb..99a2df9fa 100644 --- a/src/server/sparkd/cmds/spartan/market_data/gen/src/SnapshotFullRefreshOrderBook53.h +++ b/src/server/sparkd/cmds/spartan/market_data/gen/src/SnapshotFullRefreshOrderBook53.h @@ -4,80 +4,77 @@ #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 -#include -#include -#include -#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 +# define SBE_CONSTEXPR +# define SBE_NOEXCEPT #endif #if __cplusplus >= 201703L -#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 #include -#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) +# define SBE_BIG_ENDIAN_ENCODE_16(v) _byteswap_ushort(v) +# define SBE_BIG_ENDIAN_ENCODE_32(v) _byteswap_ulong(v) +# define SBE_BIG_ENDIAN_ENCODE_64(v) _byteswap_uint64(v) +# define SBE_LITTLE_ENDIAN_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)() @@ -89,1137 +86,1312 @@ #define SBE_NULLVALUE_UINT32 (std::numeric_limits::max)() #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -#include "AggressorSide.h" -#include "Decimal9.h" -#include "Decimal9NULL.h" -#include "DecimalQty.h" -#include "EventType.h" -#include "FLOAT.h" -#include "GroupSize.h" -#include "GroupSize8Byte.h" -#include "HaltReason.h" -#include "InstAttribValue.h" -#include "LegSide.h" -#include "MDEntryType.h" + #include "MDEntryTypeBook.h" -#include "MDEntryTypeDailyStatistics.h" -#include "MDEntryTypeStatistics.h" -#include "MDUpdateAction.h" +#include "OpenCloseSettlFlag.h" #include "MatchEventIndicator.h" #include "MaturityMonthYear.h" -#include "MessageHeader.h" -#include "OpenCloseSettlFlag.h" -#include "OrderUpdateAction.h" -#include "PRICE.h" -#include "PRICE9.h" -#include "PRICENULL.h" +#include "FLOAT.h" +#include "MDEntryTypeDailyStatistics.h" +#include "EventType.h" +#include "DecimalQty.h" +#include "MDUpdateAction.h" #include "PRICENULL9.h" -#include "PutOrCall.h" -#include "SecurityTradingEvent.h" +#include "GroupSize8Byte.h" +#include "HaltReason.h" +#include "PRICE9.h" +#include "MDEntryType.h" +#include "PRICENULL.h" #include "SecurityTradingStatus.h" +#include "LegSide.h" +#include "MessageHeader.h" +#include "PRICE.h" +#include "OrderUpdateAction.h" +#include "PutOrCall.h" #include "SecurityUpdateAction.h" +#include "SecurityTradingEvent.h" +#include "Decimal9.h" +#include "MDEntryTypeStatistics.h" +#include "InstAttribValue.h" +#include "AggressorSide.h" +#include "GroupSize.h" #include "SettlPriceType.h" +#include "Decimal9NULL.h" namespace mdp3 { -class SnapshotFullRefreshOrderBook53 { - 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 SnapshotFullRefreshOrderBook53 +{ +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; } + 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(28); + static const std::uint16_t SBE_TEMPLATE_ID = static_cast(53); + static const std::uint16_t SBE_SCHEMA_ID = static_cast(1); + static const std::uint16_t SBE_SCHEMA_VERSION = static_cast(9); - 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; + }; - SnapshotFullRefreshOrderBook53() = default; + union sbe_double_as_uint_u + { + double fp_value; + std::uint64_t uint_value; + }; - SnapshotFullRefreshOrderBook53( - 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; - SnapshotFullRefreshOrderBook53( - char *buffer, const std::uint64_t bufferLength) - : SnapshotFullRefreshOrderBook53( - buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) {} + SnapshotFullRefreshOrderBook53() = default; - SnapshotFullRefreshOrderBook53( - char *buffer, - const std::uint64_t bufferLength, - const std::uint64_t actingBlockLength, - const std::uint64_t actingVersion) - : SnapshotFullRefreshOrderBook53( - buffer, 0, bufferLength, actingBlockLength, actingVersion) {} + SnapshotFullRefreshOrderBook53( + 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) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeBlockLength() SBE_NOEXCEPT { - return (std::uint16_t)28; - } + SnapshotFullRefreshOrderBook53(char *buffer, const std::uint64_t bufferLength) : + SnapshotFullRefreshOrderBook53(buffer, 0, bufferLength, sbeBlockLength(), sbeSchemaVersion()) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeTemplateId() SBE_NOEXCEPT { - return (std::uint16_t)53; - } + SnapshotFullRefreshOrderBook53( + char *buffer, + const std::uint64_t bufferLength, + const std::uint64_t actingBlockLength, + const std::uint64_t actingVersion) : + SnapshotFullRefreshOrderBook53(buffer, 0, bufferLength, actingBlockLength, actingVersion) + { + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT { - return (std::uint16_t)1; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeBlockLength() SBE_NOEXCEPT + { + return static_cast(28); + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - sbeSchemaVersion() SBE_NOEXCEPT { - return (std::uint16_t)9; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t sbeBlockAndHeaderLength() SBE_NOEXCEPT + { + return messageHeader::encodedLength() + sbeBlockLength(); + } - SBE_NODISCARD static SBE_CONSTEXPR const char * - sbeSemanticType() SBE_NOEXCEPT { - return "W"; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeTemplateId() SBE_NOEXCEPT + { + return static_cast(53); + } - SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT { return m_offset; } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaId() SBE_NOEXCEPT + { + return static_cast(1); + } - SnapshotFullRefreshOrderBook53 &wrapForEncode( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - return *this = SnapshotFullRefreshOrderBook53( - buffer, offset, bufferLength, sbeBlockLength(), - sbeSchemaVersion()); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t sbeSchemaVersion() SBE_NOEXCEPT + { + return static_cast(9); + } - SnapshotFullRefreshOrderBook53 &wrapAndApplyHeader( - char *buffer, - const std::uint64_t offset, - const std::uint64_t bufferLength) { - MessageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); + SBE_NODISCARD static SBE_CONSTEXPR const char *sbeSemanticType() SBE_NOEXCEPT + { + return "W"; + } - hdr.blockLength(sbeBlockLength()) - .templateId(sbeTemplateId()) - .schemaId(sbeSchemaId()) - .version(sbeSchemaVersion()); + SBE_NODISCARD std::uint64_t offset() const SBE_NOEXCEPT + { + return m_offset; + } - return *this = SnapshotFullRefreshOrderBook53( - buffer, offset + MessageHeader::encodedLength(), bufferLength, - sbeBlockLength(), sbeSchemaVersion()); - } + SnapshotFullRefreshOrderBook53 &wrapForEncode(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + return *this = SnapshotFullRefreshOrderBook53(buffer, offset, bufferLength, sbeBlockLength(), sbeSchemaVersion()); + } - SnapshotFullRefreshOrderBook53 &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 = SnapshotFullRefreshOrderBook53( - buffer, offset, bufferLength, actingBlockLength, - actingVersion); - } + SnapshotFullRefreshOrderBook53 &wrapAndApplyHeader(char *buffer, const std::uint64_t offset, const std::uint64_t bufferLength) + { + messageHeader hdr(buffer, offset, bufferLength, sbeSchemaVersion()); - SBE_NODISCARD std::uint64_t sbePosition() const SBE_NOEXCEPT { - return m_position; - } + hdr + .blockLength(sbeBlockLength()) + .templateId(sbeTemplateId()) + .schemaId(sbeSchemaId()) + .version(sbeSchemaVersion()); - std::uint64_t sbeCheckPosition(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 *this = SnapshotFullRefreshOrderBook53( + buffer, + offset + messageHeader::encodedLength(), + bufferLength, + sbeBlockLength(), + sbeSchemaVersion()); + } - void sbePosition(const std::uint64_t position) { - m_position = sbeCheckPosition(position); - } + SnapshotFullRefreshOrderBook53 &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 = SnapshotFullRefreshOrderBook53(buffer, offset, bufferLength, actingBlockLength, actingVersion); + } - 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 const char *buffer() const SBE_NOEXCEPT { return m_buffer; } + // NOLINTNEXTLINE(readability-convert-member-functions-to-static) + std::uint64_t sbeCheckPosition(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 char *buffer() SBE_NOEXCEPT { return m_buffer; } + void sbePosition(const std::uint64_t position) + { + m_position = sbeCheckPosition(position); + } - SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT { - return m_bufferLength; - } + SBE_NODISCARD std::uint64_t encodedLength() const SBE_NOEXCEPT + { + return sbePosition() - m_offset; + } - SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT { - return m_actingVersion; - } + SBE_NODISCARD std::uint64_t decodeLength() const + { + SnapshotFullRefreshOrderBook53 skipper(m_buffer, m_offset, m_bufferLength, sbeBlockLength(), m_actingVersion); + skipper.skip(); + return skipper.encodedLength(); + } - SBE_NODISCARD static const char *LastMsgSeqNumProcessedMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "SeqNum"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD const char *buffer() const SBE_NOEXCEPT + { + return m_buffer; + } - static SBE_CONSTEXPR std::uint16_t lastMsgSeqNumProcessedId() SBE_NOEXCEPT { - return 369; - } + SBE_NODISCARD char *buffer() SBE_NOEXCEPT + { + return m_buffer; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - lastMsgSeqNumProcessedSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD std::uint64_t bufferLength() const SBE_NOEXCEPT + { + return m_bufferLength; + } - SBE_NODISCARD bool lastMsgSeqNumProcessedInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD std::uint64_t actingVersion() const SBE_NOEXCEPT + { + return m_actingVersion; + } + + SBE_NODISCARD static const char *LastMsgSeqNumProcessedMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "SeqNum"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t lastMsgSeqNumProcessedId() SBE_NOEXCEPT + { + return 369; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t lastMsgSeqNumProcessedSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool lastMsgSeqNumProcessedInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= lastMsgSeqNumProcessedSinceVersion(); + return m_actingVersion >= lastMsgSeqNumProcessedSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - lastMsgSeqNumProcessedEncodingOffset() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t lastMsgSeqNumProcessedEncodingOffset() SBE_NOEXCEPT + { + return 0; + } - static SBE_CONSTEXPR std::uint32_t - lastMsgSeqNumProcessedNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t lastMsgSeqNumProcessedNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t - lastMsgSeqNumProcessedMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t lastMsgSeqNumProcessedMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t - lastMsgSeqNumProcessedMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t lastMsgSeqNumProcessedMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t - lastMsgSeqNumProcessedEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t lastMsgSeqNumProcessedEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t lastMsgSeqNumProcessed() 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 lastMsgSeqNumProcessed() 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); + } - SnapshotFullRefreshOrderBook53 & - lastMsgSeqNumProcessed(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; - } + SnapshotFullRefreshOrderBook53 &lastMsgSeqNumProcessed(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 * - TotNumReportsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *TotNumReportsMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT { - return 911; - } + static SBE_CONSTEXPR std::uint16_t totNumReportsId() SBE_NOEXCEPT + { + return 911; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - totNumReportsSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t totNumReportsSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool totNumReportsInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= totNumReportsSinceVersion(); + return m_actingVersion >= totNumReportsSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - totNumReportsEncodingOffset() SBE_NOEXCEPT { - return 4; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t totNumReportsEncodingOffset() SBE_NOEXCEPT + { + return 4; + } - static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t totNumReportsMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t totNumReportsEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t totNumReports() 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); - } + SBE_NODISCARD std::uint32_t totNumReports() 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); + } - SnapshotFullRefreshOrderBook53 & - totNumReports(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; - } + SnapshotFullRefreshOrderBook53 &totNumReports(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 * - 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 8; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t securityIDEncodingOffset() SBE_NOEXCEPT + { + return 8; + } - 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 + 8, 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 + 8, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } - SnapshotFullRefreshOrderBook53 & - securityID(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; - } + SnapshotFullRefreshOrderBook53 &securityID(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 * - NoChunksMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *NoChunksMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t noChunksId() SBE_NOEXCEPT { - return 37709; - } + static SBE_CONSTEXPR std::uint16_t noChunksId() SBE_NOEXCEPT + { + return 37709; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noChunksSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noChunksSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool noChunksInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool noChunksInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= noChunksSinceVersion(); + return m_actingVersion >= noChunksSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - noChunksEncodingOffset() SBE_NOEXCEPT { - return 12; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t noChunksEncodingOffset() SBE_NOEXCEPT + { + return 12; + } - static SBE_CONSTEXPR std::uint32_t noChunksNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t noChunksNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t noChunksMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t noChunksMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t noChunksMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t noChunksMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t noChunksEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t noChunksEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t noChunks() 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 noChunks() 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); + } - SnapshotFullRefreshOrderBook53 & - noChunks(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; - } + SnapshotFullRefreshOrderBook53 &noChunks(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 * - CurrentChunkMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } + SBE_NODISCARD static const char *CurrentChunkMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } - static SBE_CONSTEXPR std::uint16_t currentChunkId() SBE_NOEXCEPT { - return 37710; - } + static SBE_CONSTEXPR std::uint16_t currentChunkId() SBE_NOEXCEPT + { + return 37710; + } - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - currentChunkSinceVersion() SBE_NOEXCEPT { - return 0; - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t currentChunkSinceVersion() SBE_NOEXCEPT + { + return 0; + } - SBE_NODISCARD bool currentChunkInActingVersion() SBE_NOEXCEPT { + SBE_NODISCARD bool currentChunkInActingVersion() SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= currentChunkSinceVersion(); + return m_actingVersion >= currentChunkSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } + } - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - currentChunkEncodingOffset() SBE_NOEXCEPT { - return 16; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t currentChunkEncodingOffset() SBE_NOEXCEPT + { + return 16; + } - static SBE_CONSTEXPR std::uint32_t currentChunkNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_UINT32; - } + static SBE_CONSTEXPR std::uint32_t currentChunkNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_UINT32; + } - static SBE_CONSTEXPR std::uint32_t currentChunkMinValue() SBE_NOEXCEPT { - return 0; - } + static SBE_CONSTEXPR std::uint32_t currentChunkMinValue() SBE_NOEXCEPT + { + return UINT32_C(0x0); + } - static SBE_CONSTEXPR std::uint32_t currentChunkMaxValue() SBE_NOEXCEPT { - return 4294967294; - } + static SBE_CONSTEXPR std::uint32_t currentChunkMaxValue() SBE_NOEXCEPT + { + return UINT32_C(0xfffffffe); + } - static SBE_CONSTEXPR std::size_t currentChunkEncodingLength() SBE_NOEXCEPT { - return 4; - } + static SBE_CONSTEXPR std::size_t currentChunkEncodingLength() SBE_NOEXCEPT + { + return 4; + } - SBE_NODISCARD std::uint32_t currentChunk() 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 currentChunk() 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); + } - SnapshotFullRefreshOrderBook53 & - currentChunk(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; - } + SnapshotFullRefreshOrderBook53 ¤tChunk(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 * - TransactTimeMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "UTCTimestamp"; - 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 "UTCTimestamp"; + 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 20; - } + SBE_NODISCARD static SBE_CONSTEXPR std::size_t transactTimeEncodingOffset() SBE_NOEXCEPT + { + return 20; + } - 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 + 20, 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 + 20, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } - SnapshotFullRefreshOrderBook53 & - transactTime(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; - } + SnapshotFullRefreshOrderBook53 &transactTime(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; + } - class NoMDEntries { + class NoMDEntries + { 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(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::uint64_t sbeHeaderSize() SBE_NOEXCEPT + { + return 3; + } + + static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT + { + return 29; + } + + 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 NoMDEntries &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(static_cast(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 *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 0; + } + + 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 + 0, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoMDEntries &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 *MDOrderPriorityMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "int"; + case MetaAttribute::PRESENCE: return "optional"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDOrderPriorityId() SBE_NOEXCEPT + { + return 37707; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDOrderPrioritySinceVersion() SBE_NOEXCEPT + { + return 7; + } + + SBE_NODISCARD bool mDOrderPriorityInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDOrderPrioritySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDOrderPriorityEncodingOffset() SBE_NOEXCEPT + { + return 8; + } + + static SBE_CONSTEXPR std::uint64_t mDOrderPriorityNullValue() SBE_NOEXCEPT + { + return UINT64_C(0xffffffffffffffff); + } + + static SBE_CONSTEXPR std::uint64_t mDOrderPriorityMinValue() SBE_NOEXCEPT + { + return UINT64_C(0x0); + } + + static SBE_CONSTEXPR std::uint64_t mDOrderPriorityMaxValue() SBE_NOEXCEPT + { + return UINT64_C(0xfffffffffffffffe); + } + + static SBE_CONSTEXPR std::size_t mDOrderPriorityEncodingLength() SBE_NOEXCEPT + { + return 8; + } + + SBE_NODISCARD std::uint64_t mDOrderPriority() const SBE_NOEXCEPT + { + if (m_actingVersion < 7) + { + return UINT64_C(0xffffffffffffffff); + } + + std::uint64_t val; + std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); + return SBE_LITTLE_ENDIAN_ENCODE_64(val); + } + + NoMDEntries &mDOrderPriority(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 *MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT + { + return 270; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryPxSinceVersion() SBE_NOEXCEPT + { + return 9; + } + + SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryPxSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryPxEncodingOffset() SBE_NOEXCEPT + { + return 16; + } + +private: + PRICE9 m_mDEntryPx; + +public: + SBE_NODISCARD PRICE9 &mDEntryPx() + { + m_mDEntryPx.wrap(m_buffer, m_offset + 16, m_actingVersion, m_bufferLength); + return m_mDEntryPx; + } + + SBE_NODISCARD static const char *MDDisplayQtyMetaAttribute(const MetaAttribute metaAttribute) SBE_NOEXCEPT + { + switch (metaAttribute) + { + case MetaAttribute::SEMANTIC_TYPE: return "Qty"; + case MetaAttribute::PRESENCE: return "required"; + default: return ""; + } + } + + static SBE_CONSTEXPR std::uint16_t mDDisplayQtyId() SBE_NOEXCEPT + { + return 37706; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDDisplayQtySinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDDisplayQtyInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDDisplayQtySinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDDisplayQtyEncodingOffset() SBE_NOEXCEPT + { + return 24; + } + + static SBE_CONSTEXPR std::int32_t mDDisplayQtyNullValue() SBE_NOEXCEPT + { + return SBE_NULLVALUE_INT32; + } + + static SBE_CONSTEXPR std::int32_t mDDisplayQtyMinValue() SBE_NOEXCEPT + { + return INT32_C(-2147483647); + } + + static SBE_CONSTEXPR std::int32_t mDDisplayQtyMaxValue() SBE_NOEXCEPT + { + return INT32_C(2147483647); + } + + static SBE_CONSTEXPR std::size_t mDDisplayQtyEncodingLength() SBE_NOEXCEPT + { + return 4; + } + + SBE_NODISCARD std::int32_t mDDisplayQty() const SBE_NOEXCEPT + { + std::int32_t val; + std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::int32_t)); + return SBE_LITTLE_ENDIAN_ENCODE_32(val); + } + + NoMDEntries &mDDisplayQty(const std::int32_t value) SBE_NOEXCEPT + { + std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); + std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::int32_t)); + return *this; + } + + SBE_NODISCARD static const char *MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT + { + return 269; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t mDEntryTypeSinceVersion() SBE_NOEXCEPT + { + return 0; + } + + SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT + { + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wtautological-compare" + #endif + return m_actingVersion >= mDEntryTypeSinceVersion(); + #if defined(__clang__) + #pragma clang diagnostic pop + #endif + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingOffset() SBE_NOEXCEPT + { + return 28; + } + + SBE_NODISCARD static SBE_CONSTEXPR std::size_t mDEntryTypeEncodingLength() SBE_NOEXCEPT + { + return 1; + } + + SBE_NODISCARD MDEntryTypeBook::Value mDEntryType() const + { + char val; + std::memcpy(&val, m_buffer + m_offset + 28, sizeof(char)); + return MDEntryTypeBook::get((val)); + } + + NoMDEntries &mDEntryType(const MDEntryTypeBook::Value value) SBE_NOEXCEPT + { + char val = (value); + std::memcpy(m_buffer + m_offset + 28, &val, sizeof(char)); + return *this; + } + + template + friend std::basic_ostream& operator << ( + std::basic_ostream& builder, NoMDEntries writer) + { + builder << '{'; + builder << R"("OrderID": )"; + builder << +writer.orderID(); + + builder << ", "; + builder << R"("MDOrderPriority": )"; + builder << +writer.mDOrderPriority(); + + builder << ", "; + builder << R"("MDEntryPx": )"; + builder << writer.mDEntryPx(); + + builder << ", "; + builder << R"("MDDisplayQty": )"; + builder << +writer.mDDisplayQty(); + + builder << ", "; + builder << R"("MDEntryType": )"; + builder << '"' << writer.mDEntryType() << '"'; + + 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: + NoMDEntries m_noMDEntries; - static SBE_CONSTEXPR std::uint64_t sbeBlockLength() SBE_NOEXCEPT { - return 29; - } +public: + SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t NoMDEntriesId() SBE_NOEXCEPT + { + return 268; + } - SBE_NODISCARD std::uint64_t sbePosition() const { return *m_positionPtr; } + SBE_NODISCARD inline NoMDEntries &noMDEntries() + { + m_noMDEntries.wrapForDecode(m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - std::uint64_t sbeCheckPosition(const std::uint64_t position) { - if (SBE_BOUNDS_CHECK_EXPECT((position > m_bufferLength), false)) { - throw std::runtime_error("buffer too short [E100]"); - } - return position; - } + NoMDEntries &noMDEntriesCount(const std::uint8_t count) + { + m_noMDEntries.wrapForEncode(m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); + return m_noMDEntries; + } - void sbePosition(const std::uint64_t position) { - *m_positionPtr = sbeCheckPosition(position); - } + SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t noMDEntriesSinceVersion() 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 NoMDEntries &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 * - 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 { + SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT + { #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wtautological-compare" #endif - return m_actingVersion >= orderIDSinceVersion(); + return m_actingVersion >= noMDEntriesSinceVersion(); #if defined(__clang__) #pragma clang diagnostic pop #endif - } - - 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 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 + 0, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoMDEntries &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 *MDOrderPriorityMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "int"; - case MetaAttribute::PRESENCE: - return "optional"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDOrderPriorityId() SBE_NOEXCEPT { - return 37707; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDOrderPrioritySinceVersion() SBE_NOEXCEPT { - return 7; - } - - SBE_NODISCARD bool mDOrderPriorityInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDOrderPrioritySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDOrderPriorityEncodingOffset() SBE_NOEXCEPT { - return 8; - } - - static SBE_CONSTEXPR std::uint64_t - mDOrderPriorityNullValue() SBE_NOEXCEPT { - return 0xffffffffffffffffL; - } - - static SBE_CONSTEXPR std::uint64_t - mDOrderPriorityMinValue() SBE_NOEXCEPT { - return 0x0L; - } - - static SBE_CONSTEXPR std::uint64_t - mDOrderPriorityMaxValue() SBE_NOEXCEPT { - return 0xfffffffffffffffeL; - } - - static SBE_CONSTEXPR std::size_t - mDOrderPriorityEncodingLength() SBE_NOEXCEPT { - return 8; - } - - SBE_NODISCARD std::uint64_t mDOrderPriority() const SBE_NOEXCEPT { - if (m_actingVersion < 7) { - return 0xffffffffffffffffL; - } - - std::uint64_t val; - std::memcpy(&val, m_buffer + m_offset + 8, sizeof(std::uint64_t)); - return SBE_LITTLE_ENDIAN_ENCODE_64(val); - } - - NoMDEntries &mDOrderPriority(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 * - MDEntryPxMetaAttribute(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 mDEntryPxId() SBE_NOEXCEPT { - return 270; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryPxSinceVersion() SBE_NOEXCEPT { - return 9; - } - - SBE_NODISCARD bool mDEntryPxInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryPxSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryPxEncodingOffset() SBE_NOEXCEPT { - return 16; - } - - private: - PRICE9 m_mDEntryPx; - - public: - SBE_NODISCARD PRICE9 &mDEntryPx() { - m_mDEntryPx.wrap( - m_buffer, m_offset + 16, m_actingVersion, m_bufferLength); - return m_mDEntryPx; - } - - SBE_NODISCARD static const char *MDDisplayQtyMetaAttribute( - const MetaAttribute metaAttribute) SBE_NOEXCEPT { - switch (metaAttribute) { - case MetaAttribute::SEMANTIC_TYPE: - return "Qty"; - case MetaAttribute::PRESENCE: - return "required"; - default: - return ""; - } - } - - static SBE_CONSTEXPR std::uint16_t mDDisplayQtyId() SBE_NOEXCEPT { - return 37706; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDDisplayQtySinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDDisplayQtyInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDDisplayQtySinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDDisplayQtyEncodingOffset() SBE_NOEXCEPT { - return 24; - } - - static SBE_CONSTEXPR std::int32_t mDDisplayQtyNullValue() SBE_NOEXCEPT { - return SBE_NULLVALUE_INT32; - } - - static SBE_CONSTEXPR std::int32_t mDDisplayQtyMinValue() SBE_NOEXCEPT { - return -2147483647; - } - - static SBE_CONSTEXPR std::int32_t mDDisplayQtyMaxValue() SBE_NOEXCEPT { - return 2147483647; - } - - static SBE_CONSTEXPR std::size_t - mDDisplayQtyEncodingLength() SBE_NOEXCEPT { - return 4; - } - - SBE_NODISCARD std::int32_t mDDisplayQty() const SBE_NOEXCEPT { - std::int32_t val; - std::memcpy(&val, m_buffer + m_offset + 24, sizeof(std::int32_t)); - return SBE_LITTLE_ENDIAN_ENCODE_32(val); - } - - NoMDEntries &mDDisplayQty(const std::int32_t value) SBE_NOEXCEPT { - std::int32_t val = SBE_LITTLE_ENDIAN_ENCODE_32(value); - std::memcpy(m_buffer + m_offset + 24, &val, sizeof(std::int32_t)); - return *this; - } - - SBE_NODISCARD static const char * - MDEntryTypeMetaAttribute(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 mDEntryTypeId() SBE_NOEXCEPT { - return 269; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - mDEntryTypeSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool mDEntryTypeInActingVersion() SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= mDEntryTypeSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingOffset() SBE_NOEXCEPT { - return 28; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::size_t - mDEntryTypeEncodingLength() SBE_NOEXCEPT { - return 1; - } - - SBE_NODISCARD MDEntryTypeBook::Value mDEntryType() const SBE_NOEXCEPT { - char val; - std::memcpy(&val, m_buffer + m_offset + 28, sizeof(char)); - return MDEntryTypeBook::get((val)); - } - - NoMDEntries & - mDEntryType(const MDEntryTypeBook::Value value) SBE_NOEXCEPT { - char val = (value); - std::memcpy(m_buffer + m_offset + 28, &val, sizeof(char)); - return *this; - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, NoMDEntries writer) { - builder << '{'; - builder << R"("OrderID": )"; - builder << +writer.orderID(); - - builder << ", "; - builder << R"("MDOrderPriority": )"; - builder << +writer.mDOrderPriority(); - - builder << ", "; - builder << R"("MDEntryPx": )"; - builder << writer.mDEntryPx(); - - builder << ", "; - builder << R"("MDDisplayQty": )"; - builder << +writer.mDDisplayQty(); - - builder << ", "; - builder << R"("MDEntryType": )"; - builder << '"' << writer.mDEntryType() << '"'; - - builder << '}'; - - return builder; - } - }; - - private: - NoMDEntries m_noMDEntries; - - public: - SBE_NODISCARD static SBE_CONSTEXPR std::uint16_t - NoMDEntriesId() SBE_NOEXCEPT { - return 268; - } - - SBE_NODISCARD inline NoMDEntries &noMDEntries() { - m_noMDEntries.wrapForDecode( - m_buffer, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - NoMDEntries &noMDEntriesCount(const std::uint8_t count) { - m_noMDEntries.wrapForEncode( - m_buffer, count, sbePositionPtr(), m_actingVersion, m_bufferLength); - return m_noMDEntries; - } - - SBE_NODISCARD static SBE_CONSTEXPR std::uint64_t - noMDEntriesSinceVersion() SBE_NOEXCEPT { - return 0; - } - - SBE_NODISCARD bool noMDEntriesInActingVersion() const SBE_NOEXCEPT { -#if defined(__clang__) -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wtautological-compare" -#endif - return m_actingVersion >= noMDEntriesSinceVersion(); -#if defined(__clang__) -#pragma clang diagnostic pop -#endif - } - - template - friend std::basic_ostream &operator<<( - std::basic_ostream &builder, - SnapshotFullRefreshOrderBook53 _writer) { - SnapshotFullRefreshOrderBook53 writer( - _writer.m_buffer, _writer.m_offset, _writer.m_bufferLength, - _writer.sbeBlockLength(), _writer.m_actingVersion); - builder << '{'; - builder << R"("Name": "SnapshotFullRefreshOrderBook53", )"; - builder << R"("sbeTemplateId": )"; - builder << writer.sbeTemplateId(); - builder << ", "; - - builder << R"("LastMsgSeqNumProcessed": )"; - builder << +writer.lastMsgSeqNumProcessed(); - - builder << ", "; - builder << R"("TotNumReports": )"; - builder << +writer.totNumReports(); - - builder << ", "; - builder << R"("SecurityID": )"; - builder << +writer.securityID(); - - builder << ", "; - builder << R"("NoChunks": )"; - builder << +writer.noChunks(); - - builder << ", "; - builder << R"("CurrentChunk": )"; - builder << +writer.currentChunk(); - - builder << ", "; - builder << R"("TransactTime": )"; - builder << +writer.transactTime(); - - builder << ", "; - { - bool atLeastOne = false; - builder << R"("NoMDEntries": [)"; - writer.noMDEntries().forEach([&](NoMDEntries &noMDEntries) { - if (atLeastOne) { - builder << ", "; + } + +template +friend std::basic_ostream& operator << ( + std::basic_ostream& builder, SnapshotFullRefreshOrderBook53 _writer) +{ + SnapshotFullRefreshOrderBook53 writer(_writer.m_buffer, _writer.m_offset, + _writer.m_bufferLength, _writer.sbeBlockLength(), _writer.m_actingVersion); + builder << '{'; + builder << R"("Name": "SnapshotFullRefreshOrderBook53", )"; + builder << R"("sbeTemplateId": )"; + builder << writer.sbeTemplateId(); + builder << ", "; + + builder << R"("LastMsgSeqNumProcessed": )"; + builder << +writer.lastMsgSeqNumProcessed(); + + builder << ", "; + builder << R"("TotNumReports": )"; + builder << +writer.totNumReports(); + + builder << ", "; + builder << R"("SecurityID": )"; + builder << +writer.securityID(); + + builder << ", "; + builder << R"("NoChunks": )"; + builder << +writer.noChunks(); + + builder << ", "; + builder << R"("CurrentChunk": )"; + builder << +writer.currentChunk(); + + builder << ", "; + builder << R"("TransactTime": )"; + builder << +writer.transactTime(); + + builder << ", "; + { + bool atLeastOne = false; + builder << R"("NoMDEntries": [)"; + writer.noMDEntries().forEach([&](NoMDEntries& noMDEntries) + { + if (atLeastOne) + { + builder << ", "; } atLeastOne = true; builder << noMDEntries; - }); - builder << ']'; - } + }); + builder << ']'; + } - builder << '}'; + builder << '}'; - return builder; - } + return builder; +} + +void skip() +{ + noMDEntries().forEach([](NoMDEntries e) + { + e.skip(); + }); +} + +SBE_NODISCARD static SBE_CONSTEXPR bool isConstLength() SBE_NOEXCEPT +{ + return false; +} + +SBE_NODISCARD static std::size_t computeLength(std::size_t noMDEntriesLength = 0) +{ +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wtype-limits" +#endif + std::size_t length = sbeBlockLength(); + + length += NoMDEntries::sbeHeaderSize(); + if (noMDEntriesLength > 254LL) + { + throw std::runtime_error("noMDEntriesLength outside of allowed range [E110]"); + } + length += noMDEntriesLength *NoMDEntries::sbeBlockLength(); + + return length; +#if defined(__GNUG__) && !defined(__clang__) +#pragma GCC diagnostic pop +#endif +} }; -} // namespace mdp3 +} #endif diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/generate.sh b/src/server/sparkd/cmds/spartan/order_execution/gen/generate.sh index 969efb075..120487bdd 100755 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/generate.sh +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/generate.sh @@ -4,21 +4,22 @@ # To update ilinkbinary.xml: # --------------------------- # The dissemination scheme is described here: -# https://cmegroup.com/confluence/display/EPICSANDBOX/iLink+3+-+Simple+Binary+Encoding#iLink3SimpleBinaryEncoding-SchemaDistribution +# https://cmegroup.com/confluence/display/EPICSANDBOX/iLink+3+-+Simple+Binary+Encoding#iLink3SimpleBinaryEncoding-SchemaDistribution # The actual files are stored here: -# sftp cmeconfig@sftpng.cmegroup.com -# password: G3t(0nnect3d -# get /MSGW/NRCert/Templates/ilinkbinary.xml +# sftp cmeconfig@sftpng.cmegroup.com +# password: G3t(0nnect3d +# Get one of: +# /MSGW/NRCert/Templates/ilinkbinary.xml +# /MSGW/Cert/Templates/ilinkbinary.xml +# /MSGW/Production/Templates/ilinkbinary.xml +# And update the corresponding nrcert, cert or prod directories # --------------------------- - # To generate CPP # --------------------------- -# Download sbe-all-[version].jar from sbe-logic github. -# Pre-built packages are available at https://search.maven.org/search?q=g:uk.co.real-logic%20sbe -# Run the docker command below which will download a jave acontainer -# and execute the jar. - +# Obtain sbe-all-[version].jar from sbe-logic github. +# Pre-built packages are available at https://search.maven.org/search?q=g:uk.co.real-logic%20sbe +# Run the docker command below which will execute the jar in a java docker container RELEASE_TYPE=${1:-prod} SBE_VERSION=1.20.4 @@ -29,18 +30,6 @@ cd $MY_DIR rm -rf src mkdir -p src -# docker run --rm -it -w $PWD \ -# -v $PWD \ -# -v /etc/group:/etc/group \ -# -v /etc/passwd:/etc/passwd \ -# -u $UID \ -# java \ -# java -Dsbe.output.dir=src \ -# -Dsbe.generate.ir="false" \ -# -Dsbe.target.language=cpp \ -# -jar ./sbe-all-$SBE_VERSION.jar \ -# $RELEASE_TYPE/ilinkbinary.xml - docker run --rm -it -w $PWD \ -v /home:/home \ -v /etc/group:/etc/group \ @@ -49,9 +38,10 @@ docker run --rm -it -w $PWD \ java \ java -Dsbe.output.dir=src \ -Dsbe.generate.ir="false" \ + -Dsbe.target.namespace="il3" \ -Dsbe.target.language=cpp \ -jar ./sbe-all-$SBE_VERSION.jar \ $RELEASE_TYPE/ilinkbinary.xml -mv src/iLinkBinary/* src/ -rmdir src/iLinkBinary/ +mv src/il3/* src/ +rmdir src/il3/ diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/AvgPxInd.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/AvgPxInd.h index c93ac57d4..6a9d1ab5d 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/AvgPxInd.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/AvgPxInd.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_AVGPXIND_H_ -#define _ILINKBINARY_AVGPXIND_H_ +#ifndef _IL3_AVGPXIND_H_ +#define _IL3_AVGPXIND_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class AvgPxInd { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/BooleanFlag.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/BooleanFlag.h index 1faff88e8..6c75da725 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/BooleanFlag.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/BooleanFlag.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_BOOLEANFLAG_H_ -#define _ILINKBINARY_BOOLEANFLAG_H_ +#ifndef _IL3_BOOLEANFLAG_H_ +#define _IL3_BOOLEANFLAG_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class BooleanFlag { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/BooleanNULL.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/BooleanNULL.h index 866ed6b42..f5c46cef7 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/BooleanNULL.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/BooleanNULL.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_BOOLEANNULL_H_ -#define _ILINKBINARY_BOOLEANNULL_H_ +#ifndef _IL3_BOOLEANNULL_H_ +#define _IL3_BOOLEANNULL_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class BooleanNULL { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/BusinessReject521.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/BusinessReject521.h index 7c1d9b6e1..64e7bf09a 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/BusinessReject521.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/BusinessReject521.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_BUSINESSREJECT521_H_ -#define _ILINKBINARY_BUSINESSREJECT521_H_ +#ifndef _IL3_BUSINESSREJECT521_H_ +#define _IL3_BUSINESSREJECT521_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class BusinessReject521 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ClearingAcctType.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ClearingAcctType.h index 0b145a7b2..beac55bf6 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ClearingAcctType.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ClearingAcctType.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_CLEARINGACCTTYPE_H_ -#define _ILINKBINARY_CLEARINGACCTTYPE_H_ +#ifndef _IL3_CLEARINGACCTTYPE_H_ +#define _IL3_CLEARINGACCTTYPE_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class ClearingAcctType { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/CmtaGiveUpCD.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/CmtaGiveUpCD.h index 79f25bf02..7c41e98c5 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/CmtaGiveUpCD.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/CmtaGiveUpCD.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_CMTAGIVEUPCD_H_ -#define _ILINKBINARY_CMTAGIVEUPCD_H_ +#ifndef _IL3_CMTAGIVEUPCD_H_ +#define _IL3_CMTAGIVEUPCD_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class CmtaGiveUpCD { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/CustOrdHandlInst.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/CustOrdHandlInst.h index 1ce5ed826..adbe8c2af 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/CustOrdHandlInst.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/CustOrdHandlInst.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_CUSTORDHANDLINST_H_ -#define _ILINKBINARY_CUSTORDHANDLINST_H_ +#ifndef _IL3_CUSTORDHANDLINST_H_ +#define _IL3_CUSTORDHANDLINST_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class CustOrdHandlInst { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/CustOrderCapacity.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/CustOrderCapacity.h index cfdc79846..acc71464e 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/CustOrderCapacity.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/CustOrderCapacity.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_CUSTORDERCAPACITY_H_ -#define _ILINKBINARY_CUSTORDERCAPACITY_H_ +#ifndef _IL3_CUSTORDERCAPACITY_H_ +#define _IL3_CUSTORDERCAPACITY_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class CustOrderCapacity { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/DATA.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/DATA.h index 84c57236e..5ff42507b 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/DATA.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/DATA.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_DATA_H_ -#define _ILINKBINARY_DATA_H_ +#ifndef _IL3_DATA_H_ +#define _IL3_DATA_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class DATA { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/DKReason.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/DKReason.h index 53d9e7bce..edc427c0c 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/DKReason.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/DKReason.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_DKREASON_H_ -#define _ILINKBINARY_DKREASON_H_ +#ifndef _IL3_DKREASON_H_ +#define _IL3_DKREASON_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class DKReason { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/Decimal32NULL.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/Decimal32NULL.h index 178540e01..a48948f48 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/Decimal32NULL.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/Decimal32NULL.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_DECIMAL32NULL_H_ -#define _ILINKBINARY_DECIMAL32NULL_H_ +#ifndef _IL3_DECIMAL32NULL_H_ +#define _IL3_DECIMAL32NULL_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class Decimal32NULL { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/Decimal64NULL.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/Decimal64NULL.h index 7c9bc6c17..a049d4ef6 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/Decimal64NULL.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/Decimal64NULL.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_DECIMAL64NULL_H_ -#define _ILINKBINARY_DECIMAL64NULL_H_ +#ifndef _IL3_DECIMAL64NULL_H_ +#define _IL3_DECIMAL64NULL_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class Decimal64NULL { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/Establish503.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/Establish503.h index c94ca0a56..7828a3948 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/Establish503.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/Establish503.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_ESTABLISH503_H_ -#define _ILINKBINARY_ESTABLISH503_H_ +#ifndef _IL3_ESTABLISH503_H_ +#define _IL3_ESTABLISH503_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class Establish503 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/EstablishmentAck504.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/EstablishmentAck504.h index 195fdccd8..f5f65b50e 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/EstablishmentAck504.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/EstablishmentAck504.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_ESTABLISHMENTACK504_H_ -#define _ILINKBINARY_ESTABLISHMENTACK504_H_ +#ifndef _IL3_ESTABLISHMENTACK504_H_ +#define _IL3_ESTABLISHMENTACK504_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class EstablishmentAck504 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/EstablishmentReject505.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/EstablishmentReject505.h index 0611e7fc2..e205fdfae 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/EstablishmentReject505.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/EstablishmentReject505.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_ESTABLISHMENTREJECT505_H_ -#define _ILINKBINARY_ESTABLISHMENTREJECT505_H_ +#ifndef _IL3_ESTABLISHMENTREJECT505_H_ +#define _IL3_ESTABLISHMENTREJECT505_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class EstablishmentReject505 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecAckStatus.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecAckStatus.h index ac884cb70..b1941d735 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecAckStatus.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecAckStatus.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXECACKSTATUS_H_ -#define _ILINKBINARY_EXECACKSTATUS_H_ +#ifndef _IL3_EXECACKSTATUS_H_ +#define _IL3_EXECACKSTATUS_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class ExecAckStatus { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecInst.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecInst.h index 66d1d6c45..61237a4bb 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecInst.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecInst.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXECINST_H_ -#define _ILINKBINARY_EXECINST_H_ +#ifndef _IL3_EXECINST_H_ +#define _IL3_EXECINST_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class ExecInst { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecMode.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecMode.h index 6cb430f84..b3a7eb717 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecMode.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecMode.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXECMODE_H_ -#define _ILINKBINARY_EXECMODE_H_ +#ifndef _IL3_EXECMODE_H_ +#define _IL3_EXECMODE_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class ExecMode { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecReason.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecReason.h index 749be985a..7b41c62a5 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecReason.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecReason.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXECREASON_H_ -#define _ILINKBINARY_EXECREASON_H_ +#ifndef _IL3_EXECREASON_H_ +#define _IL3_EXECREASON_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class ExecReason { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecTypTrdCxl.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecTypTrdCxl.h index 753cdd221..8e0c7657f 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecTypTrdCxl.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecTypTrdCxl.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXECTYPTRDCXL_H_ -#define _ILINKBINARY_EXECTYPTRDCXL_H_ +#ifndef _IL3_EXECTYPTRDCXL_H_ +#define _IL3_EXECTYPTRDCXL_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class ExecTypTrdCxl { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionAck539.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionAck539.h index 379388617..9843ba385 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionAck539.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionAck539.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXECUTIONACK539_H_ -#define _ILINKBINARY_EXECUTIONACK539_H_ +#ifndef _IL3_EXECUTIONACK539_H_ +#define _IL3_EXECUTIONACK539_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class ExecutionAck539 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportCancel534.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportCancel534.h index d716a73c3..27eddfb68 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportCancel534.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportCancel534.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXECUTIONREPORTCANCEL534_H_ -#define _ILINKBINARY_EXECUTIONREPORTCANCEL534_H_ +#ifndef _IL3_EXECUTIONREPORTCANCEL534_H_ +#define _IL3_EXECUTIONREPORTCANCEL534_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class ExecutionReportCancel534 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportElimination524.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportElimination524.h index 48f8c1895..27af6d072 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportElimination524.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportElimination524.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXECUTIONREPORTELIMINATION524_H_ -#define _ILINKBINARY_EXECUTIONREPORTELIMINATION524_H_ +#ifndef _IL3_EXECUTIONREPORTELIMINATION524_H_ +#define _IL3_EXECUTIONREPORTELIMINATION524_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class ExecutionReportElimination524 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportModify531.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportModify531.h index e37ba092b..de2fdd25d 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportModify531.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportModify531.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXECUTIONREPORTMODIFY531_H_ -#define _ILINKBINARY_EXECUTIONREPORTMODIFY531_H_ +#ifndef _IL3_EXECUTIONREPORTMODIFY531_H_ +#define _IL3_EXECUTIONREPORTMODIFY531_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class ExecutionReportModify531 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportNew522.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportNew522.h index 2754ab67c..1b48a1fe1 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportNew522.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportNew522.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXECUTIONREPORTNEW522_H_ -#define _ILINKBINARY_EXECUTIONREPORTNEW522_H_ +#ifndef _IL3_EXECUTIONREPORTNEW522_H_ +#define _IL3_EXECUTIONREPORTNEW522_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class ExecutionReportNew522 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportReject523.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportReject523.h index 4fa94ef16..48be7644c 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportReject523.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportReject523.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXECUTIONREPORTREJECT523_H_ -#define _ILINKBINARY_EXECUTIONREPORTREJECT523_H_ +#ifndef _IL3_EXECUTIONREPORTREJECT523_H_ +#define _IL3_EXECUTIONREPORTREJECT523_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class ExecutionReportReject523 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportStatus532.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportStatus532.h index 384dccd1f..87148158a 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportStatus532.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportStatus532.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXECUTIONREPORTSTATUS532_H_ -#define _ILINKBINARY_EXECUTIONREPORTSTATUS532_H_ +#ifndef _IL3_EXECUTIONREPORTSTATUS532_H_ +#define _IL3_EXECUTIONREPORTSTATUS532_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class ExecutionReportStatus532 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeAddendumOutright548.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeAddendumOutright548.h index 5efb371ed..3912e3a89 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeAddendumOutright548.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeAddendumOutright548.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXECUTIONREPORTTRADEADDENDUMOUTRIGHT548_H_ -#define _ILINKBINARY_EXECUTIONREPORTTRADEADDENDUMOUTRIGHT548_H_ +#ifndef _IL3_EXECUTIONREPORTTRADEADDENDUMOUTRIGHT548_H_ +#define _IL3_EXECUTIONREPORTTRADEADDENDUMOUTRIGHT548_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class ExecutionReportTradeAddendumOutright548 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeAddendumSpread549.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeAddendumSpread549.h index 3a7fbffcf..632efab0d 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeAddendumSpread549.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeAddendumSpread549.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXECUTIONREPORTTRADEADDENDUMSPREAD549_H_ -#define _ILINKBINARY_EXECUTIONREPORTTRADEADDENDUMSPREAD549_H_ +#ifndef _IL3_EXECUTIONREPORTTRADEADDENDUMSPREAD549_H_ +#define _IL3_EXECUTIONREPORTTRADEADDENDUMSPREAD549_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class ExecutionReportTradeAddendumSpread549 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeAddendumSpreadLeg550.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeAddendumSpreadLeg550.h index a9eb90880..2162fabb5 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeAddendumSpreadLeg550.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeAddendumSpreadLeg550.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXECUTIONREPORTTRADEADDENDUMSPREADLEG550_H_ -#define _ILINKBINARY_EXECUTIONREPORTTRADEADDENDUMSPREADLEG550_H_ +#ifndef _IL3_EXECUTIONREPORTTRADEADDENDUMSPREADLEG550_H_ +#define _IL3_EXECUTIONREPORTTRADEADDENDUMSPREADLEG550_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class ExecutionReportTradeAddendumSpreadLeg550 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeOutright525.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeOutright525.h index 963f00744..35398176c 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeOutright525.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeOutright525.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXECUTIONREPORTTRADEOUTRIGHT525_H_ -#define _ILINKBINARY_EXECUTIONREPORTTRADEOUTRIGHT525_H_ +#ifndef _IL3_EXECUTIONREPORTTRADEOUTRIGHT525_H_ +#define _IL3_EXECUTIONREPORTTRADEOUTRIGHT525_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class ExecutionReportTradeOutright525 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeSpread526.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeSpread526.h index 282001814..1f557c030 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeSpread526.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeSpread526.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXECUTIONREPORTTRADESPREAD526_H_ -#define _ILINKBINARY_EXECUTIONREPORTTRADESPREAD526_H_ +#ifndef _IL3_EXECUTIONREPORTTRADESPREAD526_H_ +#define _IL3_EXECUTIONREPORTTRADESPREAD526_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class ExecutionReportTradeSpread526 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeSpreadLeg527.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeSpreadLeg527.h index 1701b3581..7e999b756 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeSpreadLeg527.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExecutionReportTradeSpreadLeg527.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXECUTIONREPORTTRADESPREADLEG527_H_ -#define _ILINKBINARY_EXECUTIONREPORTTRADESPREADLEG527_H_ +#ifndef _IL3_EXECUTIONREPORTTRADESPREADLEG527_H_ +#define _IL3_EXECUTIONREPORTTRADESPREADLEG527_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class ExecutionReportTradeSpreadLeg527 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExpCycle.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExpCycle.h index 9b4ed2940..418e22c48 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExpCycle.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ExpCycle.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_EXPCYCLE_H_ -#define _ILINKBINARY_EXPCYCLE_H_ +#ifndef _IL3_EXPCYCLE_H_ +#define _IL3_EXPCYCLE_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class ExpCycle { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/FTI.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/FTI.h index ebdb932e8..4b0b03ce8 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/FTI.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/FTI.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_FTI_H_ -#define _ILINKBINARY_FTI_H_ +#ifndef _IL3_FTI_H_ +#define _IL3_FTI_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class FTI { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/GroupSize.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/GroupSize.h index 77804e1a2..88a80234b 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/GroupSize.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/GroupSize.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_GROUPSIZE_H_ -#define _ILINKBINARY_GROUPSIZE_H_ +#ifndef _IL3_GROUPSIZE_H_ +#define _IL3_GROUPSIZE_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class GroupSize { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/KeepAliveLapsed.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/KeepAliveLapsed.h index 56721e9b3..37e776900 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/KeepAliveLapsed.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/KeepAliveLapsed.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_KEEPALIVELAPSED_H_ -#define _ILINKBINARY_KEEPALIVELAPSED_H_ +#ifndef _IL3_KEEPALIVELAPSED_H_ +#define _IL3_KEEPALIVELAPSED_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class KeepAliveLapsed { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ListUpdAct.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ListUpdAct.h index 3dea9d8fd..93ef8f637 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ListUpdAct.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ListUpdAct.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_LISTUPDACT_H_ -#define _ILINKBINARY_LISTUPDACT_H_ +#ifndef _IL3_LISTUPDACT_H_ +#define _IL3_LISTUPDACT_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class ListUpdAct { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ManualOrdInd.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ManualOrdInd.h index b859bfb97..bf347a666 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ManualOrdInd.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ManualOrdInd.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_MANUALORDIND_H_ -#define _ILINKBINARY_MANUALORDIND_H_ +#ifndef _IL3_MANUALORDIND_H_ +#define _IL3_MANUALORDIND_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class ManualOrdInd { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ManualOrdIndReq.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ManualOrdIndReq.h index 6c8ab4930..d8c48334d 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ManualOrdIndReq.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ManualOrdIndReq.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_MANUALORDINDREQ_H_ -#define _ILINKBINARY_MANUALORDINDREQ_H_ +#ifndef _IL3_MANUALORDINDREQ_H_ +#define _IL3_MANUALORDINDREQ_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class ManualOrdIndReq { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassActionOrdTyp.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassActionOrdTyp.h index df87d4dc4..6e1b371d1 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassActionOrdTyp.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassActionOrdTyp.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_MASSACTIONORDTYP_H_ -#define _ILINKBINARY_MASSACTIONORDTYP_H_ +#ifndef _IL3_MASSACTIONORDTYP_H_ +#define _IL3_MASSACTIONORDTYP_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class MassActionOrdTyp { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassActionResponse.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassActionResponse.h index eca52b837..c9141a406 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassActionResponse.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassActionResponse.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_MASSACTIONRESPONSE_H_ -#define _ILINKBINARY_MASSACTIONRESPONSE_H_ +#ifndef _IL3_MASSACTIONRESPONSE_H_ +#define _IL3_MASSACTIONRESPONSE_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class MassActionResponse { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassActionScope.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassActionScope.h index d99de58fc..53d0f9cb3 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassActionScope.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassActionScope.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_MASSACTIONSCOPE_H_ -#define _ILINKBINARY_MASSACTIONSCOPE_H_ +#ifndef _IL3_MASSACTIONSCOPE_H_ +#define _IL3_MASSACTIONSCOPE_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class MassActionScope { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassCancelTIF.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassCancelTIF.h index 19df73e07..52817d1cd 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassCancelTIF.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassCancelTIF.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_MASSCANCELTIF_H_ -#define _ILINKBINARY_MASSCANCELTIF_H_ +#ifndef _IL3_MASSCANCELTIF_H_ +#define _IL3_MASSCANCELTIF_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class MassCancelTIF { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassCxlReqTyp.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassCxlReqTyp.h index b3ca9ba15..bac464634 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassCxlReqTyp.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassCxlReqTyp.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_MASSCXLREQTYP_H_ -#define _ILINKBINARY_MASSCXLREQTYP_H_ +#ifndef _IL3_MASSCXLREQTYP_H_ +#define _IL3_MASSCXLREQTYP_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class MassCxlReqTyp { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassQuote517.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassQuote517.h index ba0be5743..6cea82999 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassQuote517.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassQuote517.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_MASSQUOTE517_H_ -#define _ILINKBINARY_MASSQUOTE517_H_ +#ifndef _IL3_MASSQUOTE517_H_ +#define _IL3_MASSQUOTE517_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class MassQuote517 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassQuoteAck545.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassQuoteAck545.h index cf21dba33..3c016a3b0 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassQuoteAck545.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassQuoteAck545.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_MASSQUOTEACK545_H_ -#define _ILINKBINARY_MASSQUOTEACK545_H_ +#ifndef _IL3_MASSQUOTEACK545_H_ +#define _IL3_MASSQUOTEACK545_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class MassQuoteAck545 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassStatusOrdTyp.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassStatusOrdTyp.h index 98f9b359c..ca7bdf2b6 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassStatusOrdTyp.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassStatusOrdTyp.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_MASSSTATUSORDTYP_H_ -#define _ILINKBINARY_MASSSTATUSORDTYP_H_ +#ifndef _IL3_MASSSTATUSORDTYP_H_ +#define _IL3_MASSSTATUSORDTYP_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class MassStatusOrdTyp { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassStatusReqTyp.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassStatusReqTyp.h index cd041aca2..ff7a023a2 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassStatusReqTyp.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassStatusReqTyp.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_MASSSTATUSREQTYP_H_ -#define _ILINKBINARY_MASSSTATUSREQTYP_H_ +#ifndef _IL3_MASSSTATUSREQTYP_H_ +#define _IL3_MASSSTATUSREQTYP_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class MassStatusReqTyp { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassStatusTIF.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassStatusTIF.h index e12b81bf0..9d90163c3 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassStatusTIF.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MassStatusTIF.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_MASSSTATUSTIF_H_ -#define _ILINKBINARY_MASSSTATUSTIF_H_ +#ifndef _IL3_MASSSTATUSTIF_H_ +#define _IL3_MASSSTATUSTIF_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class MassStatusTIF { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MaturityMonthYear.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MaturityMonthYear.h index 6accd6257..a8d738b75 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MaturityMonthYear.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MaturityMonthYear.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_MATURITYMONTHYEAR_H_ -#define _ILINKBINARY_MATURITYMONTHYEAR_H_ +#ifndef _IL3_MATURITYMONTHYEAR_H_ +#define _IL3_MATURITYMONTHYEAR_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class MaturityMonthYear { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MessageHeader.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MessageHeader.h index c514b0dd0..ebc5dca6c 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/MessageHeader.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/MessageHeader.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_MESSAGEHEADER_H_ -#define _ILINKBINARY_MESSAGEHEADER_H_ +#ifndef _IL3_MESSAGEHEADER_H_ +#define _IL3_MESSAGEHEADER_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class MessageHeader { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/Negotiate500.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/Negotiate500.h index ebfa0d682..6dbc0bff5 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/Negotiate500.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/Negotiate500.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_NEGOTIATE500_H_ -#define _ILINKBINARY_NEGOTIATE500_H_ +#ifndef _IL3_NEGOTIATE500_H_ +#define _IL3_NEGOTIATE500_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class Negotiate500 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/NegotiationReject502.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/NegotiationReject502.h index 17ec6ee3d..5fa62ccb5 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/NegotiationReject502.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/NegotiationReject502.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_NEGOTIATIONREJECT502_H_ -#define _ILINKBINARY_NEGOTIATIONREJECT502_H_ +#ifndef _IL3_NEGOTIATIONREJECT502_H_ +#define _IL3_NEGOTIATIONREJECT502_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class NegotiationReject502 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/NegotiationResponse501.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/NegotiationResponse501.h index 6670a07e3..32a57f4c7 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/NegotiationResponse501.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/NegotiationResponse501.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_NEGOTIATIONRESPONSE501_H_ -#define _ILINKBINARY_NEGOTIATIONRESPONSE501_H_ +#ifndef _IL3_NEGOTIATIONRESPONSE501_H_ +#define _IL3_NEGOTIATIONRESPONSE501_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class NegotiationResponse501 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/NewOrderCross544.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/NewOrderCross544.h index ca52a39ff..d8b3ee21d 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/NewOrderCross544.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/NewOrderCross544.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_NEWORDERCROSS544_H_ -#define _ILINKBINARY_NEWORDERCROSS544_H_ +#ifndef _IL3_NEWORDERCROSS544_H_ +#define _IL3_NEWORDERCROSS544_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class NewOrderCross544 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/NewOrderSingle514.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/NewOrderSingle514.h index 076dab256..76b5c1dad 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/NewOrderSingle514.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/NewOrderSingle514.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_NEWORDERSINGLE514_H_ -#define _ILINKBINARY_NEWORDERSINGLE514_H_ +#ifndef _IL3_NEWORDERSINGLE514_H_ +#define _IL3_NEWORDERSINGLE514_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class NewOrderSingle514 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/NotApplied513.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/NotApplied513.h index d96c0f959..8e3bf50c1 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/NotApplied513.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/NotApplied513.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_NOTAPPLIED513_H_ -#define _ILINKBINARY_NOTAPPLIED513_H_ +#ifndef _IL3_NOTAPPLIED513_H_ +#define _IL3_NOTAPPLIED513_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class NotApplied513 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OFMOverrideReq.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OFMOverrideReq.h index 23c00f3d6..441ad2671 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OFMOverrideReq.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OFMOverrideReq.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_OFMOVERRIDEREQ_H_ -#define _ILINKBINARY_OFMOVERRIDEREQ_H_ +#ifndef _IL3_OFMOVERRIDEREQ_H_ +#define _IL3_OFMOVERRIDEREQ_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class OFMOverrideReq { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrdStatusTrd.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrdStatusTrd.h index 9b33f4e87..d0db9f556 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrdStatusTrd.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrdStatusTrd.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_ORDSTATUSTRD_H_ -#define _ILINKBINARY_ORDSTATUSTRD_H_ +#ifndef _IL3_ORDSTATUSTRD_H_ +#define _IL3_ORDSTATUSTRD_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class OrdStatusTrd { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrdStatusTrdCxl.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrdStatusTrdCxl.h index a165ef92d..d9c6e0f85 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrdStatusTrdCxl.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrdStatusTrdCxl.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_ORDSTATUSTRDCXL_H_ -#define _ILINKBINARY_ORDSTATUSTRDCXL_H_ +#ifndef _IL3_ORDSTATUSTRDCXL_H_ +#define _IL3_ORDSTATUSTRDCXL_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class OrdStatusTrdCxl { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderCancelReject535.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderCancelReject535.h index a2566333f..781a680f8 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderCancelReject535.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderCancelReject535.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_ORDERCANCELREJECT535_H_ -#define _ILINKBINARY_ORDERCANCELREJECT535_H_ +#ifndef _IL3_ORDERCANCELREJECT535_H_ +#define _IL3_ORDERCANCELREJECT535_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class OrderCancelReject535 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderCancelReplaceReject536.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderCancelReplaceReject536.h index 1dbdf47d0..aa43b08a5 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderCancelReplaceReject536.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderCancelReplaceReject536.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_ORDERCANCELREPLACEREJECT536_H_ -#define _ILINKBINARY_ORDERCANCELREPLACEREJECT536_H_ +#ifndef _IL3_ORDERCANCELREPLACEREJECT536_H_ +#define _IL3_ORDERCANCELREPLACEREJECT536_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class OrderCancelReplaceReject536 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderCancelReplaceRequest515.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderCancelReplaceRequest515.h index 063f6ad8d..e81eb514d 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderCancelReplaceRequest515.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderCancelReplaceRequest515.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_ORDERCANCELREPLACEREQUEST515_H_ -#define _ILINKBINARY_ORDERCANCELREPLACEREQUEST515_H_ +#ifndef _IL3_ORDERCANCELREPLACEREQUEST515_H_ +#define _IL3_ORDERCANCELREPLACEREQUEST515_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class OrderCancelReplaceRequest515 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderCancelRequest516.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderCancelRequest516.h index 6d87f3189..6935a5fcd 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderCancelRequest516.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderCancelRequest516.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_ORDERCANCELREQUEST516_H_ -#define _ILINKBINARY_ORDERCANCELREQUEST516_H_ +#ifndef _IL3_ORDERCANCELREQUEST516_H_ +#define _IL3_ORDERCANCELREQUEST516_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class OrderCancelRequest516 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderEventType.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderEventType.h index 07ffe031b..8b0e10e0d 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderEventType.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderEventType.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_ORDEREVENTTYPE_H_ -#define _ILINKBINARY_ORDEREVENTTYPE_H_ +#ifndef _IL3_ORDEREVENTTYPE_H_ +#define _IL3_ORDEREVENTTYPE_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class OrderEventType { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderMassActionReport562.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderMassActionReport562.h index 7530f9546..91dc75ae1 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderMassActionReport562.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderMassActionReport562.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_ORDERMASSACTIONREPORT562_H_ -#define _ILINKBINARY_ORDERMASSACTIONREPORT562_H_ +#ifndef _IL3_ORDERMASSACTIONREPORT562_H_ +#define _IL3_ORDERMASSACTIONREPORT562_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class OrderMassActionReport562 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderMassActionRequest529.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderMassActionRequest529.h index 6fd335e29..f1df40429 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderMassActionRequest529.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderMassActionRequest529.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_ORDERMASSACTIONREQUEST529_H_ -#define _ILINKBINARY_ORDERMASSACTIONREQUEST529_H_ +#ifndef _IL3_ORDERMASSACTIONREQUEST529_H_ +#define _IL3_ORDERMASSACTIONREQUEST529_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class OrderMassActionRequest529 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderMassStatusRequest530.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderMassStatusRequest530.h index 33b265043..408ff4e78 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderMassStatusRequest530.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderMassStatusRequest530.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_ORDERMASSSTATUSREQUEST530_H_ -#define _ILINKBINARY_ORDERMASSSTATUSREQUEST530_H_ +#ifndef _IL3_ORDERMASSSTATUSREQUEST530_H_ +#define _IL3_ORDERMASSSTATUSREQUEST530_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class OrderMassStatusRequest530 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderStatus.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderStatus.h index 0477468db..ad30524d1 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderStatus.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderStatus.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_ORDERSTATUS_H_ -#define _ILINKBINARY_ORDERSTATUS_H_ +#ifndef _IL3_ORDERSTATUS_H_ +#define _IL3_ORDERSTATUS_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class OrderStatus { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderStatusRequest533.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderStatusRequest533.h index 95a0fc051..a63e0d478 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderStatusRequest533.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderStatusRequest533.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_ORDERSTATUSREQUEST533_H_ -#define _ILINKBINARY_ORDERSTATUSREQUEST533_H_ +#ifndef _IL3_ORDERSTATUSREQUEST533_H_ +#define _IL3_ORDERSTATUSREQUEST533_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class OrderStatusRequest533 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderType.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderType.h index d61b150ea..cd41084bc 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderType.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderType.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_ORDERTYPE_H_ -#define _ILINKBINARY_ORDERTYPE_H_ +#ifndef _IL3_ORDERTYPE_H_ +#define _IL3_ORDERTYPE_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class OrderType { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderTypeReq.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderTypeReq.h index d643c2c10..6bde962e6 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderTypeReq.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/OrderTypeReq.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_ORDERTYPEREQ_H_ -#define _ILINKBINARY_ORDERTYPEREQ_H_ +#ifndef _IL3_ORDERTYPEREQ_H_ +#define _IL3_ORDERTYPEREQ_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class OrderTypeReq { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/PRICE9.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/PRICE9.h index 3e0cbf6df..57fbf7c08 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/PRICE9.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/PRICE9.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_PRICE9_H_ -#define _ILINKBINARY_PRICE9_H_ +#ifndef _IL3_PRICE9_H_ +#define _IL3_PRICE9_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class PRICE9 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/PRICENULL9.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/PRICENULL9.h index 115c54e69..3a6b27c0f 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/PRICENULL9.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/PRICENULL9.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_PRICENULL9_H_ -#define _ILINKBINARY_PRICENULL9_H_ +#ifndef _IL3_PRICENULL9_H_ +#define _IL3_PRICENULL9_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class PRICENULL9 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailRole.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailRole.h index 518e56625..cddedee25 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailRole.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailRole.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_PARTYDETAILROLE_H_ -#define _ILINKBINARY_PARTYDETAILROLE_H_ +#ifndef _IL3_PARTYDETAILROLE_H_ +#define _IL3_PARTYDETAILROLE_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class PartyDetailRole { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailsDefinitionRequest518.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailsDefinitionRequest518.h index 14d240cb4..c3d3c1087 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailsDefinitionRequest518.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailsDefinitionRequest518.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_PARTYDETAILSDEFINITIONREQUEST518_H_ -#define _ILINKBINARY_PARTYDETAILSDEFINITIONREQUEST518_H_ +#ifndef _IL3_PARTYDETAILSDEFINITIONREQUEST518_H_ +#define _IL3_PARTYDETAILSDEFINITIONREQUEST518_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class PartyDetailsDefinitionRequest518 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailsDefinitionRequestAck519.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailsDefinitionRequestAck519.h index 0425b6feb..38db918cc 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailsDefinitionRequestAck519.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailsDefinitionRequestAck519.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_PARTYDETAILSDEFINITIONREQUESTACK519_H_ -#define _ILINKBINARY_PARTYDETAILSDEFINITIONREQUESTACK519_H_ +#ifndef _IL3_PARTYDETAILSDEFINITIONREQUESTACK519_H_ +#define _IL3_PARTYDETAILSDEFINITIONREQUESTACK519_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class PartyDetailsDefinitionRequestAck519 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailsListReport538.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailsListReport538.h index 02dda69a6..3d9d817fd 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailsListReport538.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailsListReport538.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_PARTYDETAILSLISTREPORT538_H_ -#define _ILINKBINARY_PARTYDETAILSLISTREPORT538_H_ +#ifndef _IL3_PARTYDETAILSLISTREPORT538_H_ +#define _IL3_PARTYDETAILSLISTREPORT538_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class PartyDetailsListReport538 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailsListRequest537.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailsListRequest537.h index 61173a95a..e645cfc1a 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailsListRequest537.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/PartyDetailsListRequest537.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_PARTYDETAILSLISTREQUEST537_H_ -#define _ILINKBINARY_PARTYDETAILSLISTREQUEST537_H_ +#ifndef _IL3_PARTYDETAILSLISTREQUEST537_H_ +#define _IL3_PARTYDETAILSLISTREQUEST537_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class PartyDetailsListRequest537 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteAckStatus.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteAckStatus.h index e07194619..c2aa20cc9 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteAckStatus.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteAckStatus.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_QUOTEACKSTATUS_H_ -#define _ILINKBINARY_QUOTEACKSTATUS_H_ +#ifndef _IL3_QUOTEACKSTATUS_H_ +#define _IL3_QUOTEACKSTATUS_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class QuoteAckStatus { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteCancel528.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteCancel528.h index da0d77f21..07ff77aec 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteCancel528.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteCancel528.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_QUOTECANCEL528_H_ -#define _ILINKBINARY_QUOTECANCEL528_H_ +#ifndef _IL3_QUOTECANCEL528_H_ +#define _IL3_QUOTECANCEL528_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class QuoteCancel528 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteCancelAck563.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteCancelAck563.h index 76d9143fe..d833038b4 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteCancelAck563.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteCancelAck563.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_QUOTECANCELACK563_H_ -#define _ILINKBINARY_QUOTECANCELACK563_H_ +#ifndef _IL3_QUOTECANCELACK563_H_ +#define _IL3_QUOTECANCELACK563_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class QuoteCancelAck563 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteCxlStatus.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteCxlStatus.h index c2331d096..09eede5c6 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteCxlStatus.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteCxlStatus.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_QUOTECXLSTATUS_H_ -#define _ILINKBINARY_QUOTECXLSTATUS_H_ +#ifndef _IL3_QUOTECXLSTATUS_H_ +#define _IL3_QUOTECXLSTATUS_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class QuoteCxlStatus { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteCxlTyp.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteCxlTyp.h index 043614966..5601eb404 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteCxlTyp.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteCxlTyp.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_QUOTECXLTYP_H_ -#define _ILINKBINARY_QUOTECXLTYP_H_ +#ifndef _IL3_QUOTECXLTYP_H_ +#define _IL3_QUOTECXLTYP_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class QuoteCxlTyp { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteTyp.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteTyp.h index dd478bb15..8e14f5f14 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteTyp.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/QuoteTyp.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_QUOTETYP_H_ -#define _ILINKBINARY_QUOTETYP_H_ +#ifndef _IL3_QUOTETYP_H_ +#define _IL3_QUOTETYP_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class QuoteTyp { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/RFQSide.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/RFQSide.h index 04bffac67..54347d473 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/RFQSide.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/RFQSide.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_RFQSIDE_H_ -#define _ILINKBINARY_RFQSIDE_H_ +#ifndef _IL3_RFQSIDE_H_ +#define _IL3_RFQSIDE_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class RFQSide { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ReqResult.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ReqResult.h index 237b59e0f..26e557fa5 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ReqResult.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ReqResult.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_REQRESULT_H_ -#define _ILINKBINARY_REQRESULT_H_ +#ifndef _IL3_REQRESULT_H_ +#define _IL3_REQRESULT_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class ReqResult { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/RequestForQuote543.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/RequestForQuote543.h index 857379c90..42d1e37ab 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/RequestForQuote543.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/RequestForQuote543.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_REQUESTFORQUOTE543_H_ -#define _ILINKBINARY_REQUESTFORQUOTE543_H_ +#ifndef _IL3_REQUESTFORQUOTE543_H_ +#define _IL3_REQUESTFORQUOTE543_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class RequestForQuote543 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/RequestForQuoteAck546.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/RequestForQuoteAck546.h index 85d267f0d..68d36ad0f 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/RequestForQuoteAck546.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/RequestForQuoteAck546.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_REQUESTFORQUOTEACK546_H_ -#define _ILINKBINARY_REQUESTFORQUOTEACK546_H_ +#ifndef _IL3_REQUESTFORQUOTEACK546_H_ +#define _IL3_REQUESTFORQUOTEACK546_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class RequestForQuoteAck546 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/Retransmission509.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/Retransmission509.h index cd408599d..b42a19f59 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/Retransmission509.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/Retransmission509.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_RETRANSMISSION509_H_ -#define _ILINKBINARY_RETRANSMISSION509_H_ +#ifndef _IL3_RETRANSMISSION509_H_ +#define _IL3_RETRANSMISSION509_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class Retransmission509 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/RetransmitReject510.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/RetransmitReject510.h index f5c6097c3..cb1d17f25 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/RetransmitReject510.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/RetransmitReject510.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_RETRANSMITREJECT510_H_ -#define _ILINKBINARY_RETRANSMITREJECT510_H_ +#ifndef _IL3_RETRANSMITREJECT510_H_ +#define _IL3_RETRANSMITREJECT510_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class RetransmitReject510 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/RetransmitRequest508.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/RetransmitRequest508.h index 6543ade71..6fba09768 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/RetransmitRequest508.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/RetransmitRequest508.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_RETRANSMITREQUEST508_H_ -#define _ILINKBINARY_RETRANSMITREQUEST508_H_ +#ifndef _IL3_RETRANSMITREQUEST508_H_ +#define _IL3_RETRANSMITREQUEST508_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class RetransmitRequest508 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/SLEDS.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/SLEDS.h index 5553e6491..45f0be73c 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/SLEDS.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/SLEDS.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_SLEDS_H_ -#define _ILINKBINARY_SLEDS_H_ +#ifndef _IL3_SLEDS_H_ +#define _IL3_SLEDS_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class SLEDS { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/SMPI.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/SMPI.h index dd2875d39..75ec73e60 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/SMPI.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/SMPI.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_SMPI_H_ -#define _ILINKBINARY_SMPI_H_ +#ifndef _IL3_SMPI_H_ +#define _IL3_SMPI_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class SMPI { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/SecRspTyp.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/SecRspTyp.h index fab0c684e..443c0037f 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/SecRspTyp.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/SecRspTyp.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_SECRSPTYP_H_ -#define _ILINKBINARY_SECRSPTYP_H_ +#ifndef _IL3_SECRSPTYP_H_ +#define _IL3_SECRSPTYP_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class SecRspTyp { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/SecurityDefinitionRequest560.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/SecurityDefinitionRequest560.h index a63e4895a..61d2bf17a 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/SecurityDefinitionRequest560.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/SecurityDefinitionRequest560.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_SECURITYDEFINITIONREQUEST560_H_ -#define _ILINKBINARY_SECURITYDEFINITIONREQUEST560_H_ +#ifndef _IL3_SECURITYDEFINITIONREQUEST560_H_ +#define _IL3_SECURITYDEFINITIONREQUEST560_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class SecurityDefinitionRequest560 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/SecurityDefinitionResponse561.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/SecurityDefinitionResponse561.h index bfd1bf3cd..c75f3b475 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/SecurityDefinitionResponse561.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/SecurityDefinitionResponse561.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_SECURITYDEFINITIONRESPONSE561_H_ -#define _ILINKBINARY_SECURITYDEFINITIONRESPONSE561_H_ +#ifndef _IL3_SECURITYDEFINITIONRESPONSE561_H_ +#define _IL3_SECURITYDEFINITIONRESPONSE561_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class SecurityDefinitionResponse561 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/Sequence506.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/Sequence506.h index 4f20864c2..7b45c1d71 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/Sequence506.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/Sequence506.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_SEQUENCE506_H_ -#define _ILINKBINARY_SEQUENCE506_H_ +#ifndef _IL3_SEQUENCE506_H_ +#define _IL3_SEQUENCE506_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class Sequence506 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ShortSaleType.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ShortSaleType.h index 1f1c0c543..0856a2356 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/ShortSaleType.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/ShortSaleType.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_SHORTSALETYPE_H_ -#define _ILINKBINARY_SHORTSALETYPE_H_ +#ifndef _IL3_SHORTSALETYPE_H_ +#define _IL3_SHORTSALETYPE_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class ShortSaleType { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/SideNULL.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/SideNULL.h index 71dc4b3e2..f3614ec09 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/SideNULL.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/SideNULL.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_SIDENULL_H_ -#define _ILINKBINARY_SIDENULL_H_ +#ifndef _IL3_SIDENULL_H_ +#define _IL3_SIDENULL_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class SideNULL { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/SideReq.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/SideReq.h index cd3cd8b01..c52792aa1 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/SideReq.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/SideReq.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_SIDEREQ_H_ -#define _ILINKBINARY_SIDEREQ_H_ +#ifndef _IL3_SIDEREQ_H_ +#define _IL3_SIDEREQ_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class SideReq { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/SideTimeInForce.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/SideTimeInForce.h index 28bf22930..aa7c5100c 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/SideTimeInForce.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/SideTimeInForce.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_SIDETIMEINFORCE_H_ -#define _ILINKBINARY_SIDETIMEINFORCE_H_ +#ifndef _IL3_SIDETIMEINFORCE_H_ +#define _IL3_SIDETIMEINFORCE_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class SideTimeInForce { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/SplitMsg.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/SplitMsg.h index e071df893..7c8ba41fc 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/SplitMsg.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/SplitMsg.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_SPLITMSG_H_ -#define _ILINKBINARY_SPLITMSG_H_ +#ifndef _IL3_SPLITMSG_H_ +#define _IL3_SPLITMSG_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class SplitMsg { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/Terminate507.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/Terminate507.h index 56e6f79b9..3daf500cc 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/Terminate507.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/Terminate507.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_TERMINATE507_H_ -#define _ILINKBINARY_TERMINATE507_H_ +#ifndef _IL3_TERMINATE507_H_ +#define _IL3_TERMINATE507_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -147,7 +147,7 @@ #include "ExecMode.h" #include "QuoteTyp.h" -namespace iLinkBinary { +namespace il3 { class Terminate507 { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/TimeInForce.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/TimeInForce.h index 10454a9ef..9d07ea759 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/TimeInForce.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/TimeInForce.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_TIMEINFORCE_H_ -#define _ILINKBINARY_TIMEINFORCE_H_ +#ifndef _IL3_TIMEINFORCE_H_ +#define _IL3_TIMEINFORCE_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class TimeInForce { diff --git a/src/server/sparkd/cmds/spartan/order_execution/gen/src/TradeAddendum.h b/src/server/sparkd/cmds/spartan/order_execution/gen/src/TradeAddendum.h index 9adb02444..5e7507cab 100644 --- a/src/server/sparkd/cmds/spartan/order_execution/gen/src/TradeAddendum.h +++ b/src/server/sparkd/cmds/spartan/order_execution/gen/src/TradeAddendum.h @@ -1,6 +1,6 @@ /* Generated SBE (Simple Binary Encoding) message codec */ -#ifndef _ILINKBINARY_TRADEADDENDUM_H_ -#define _ILINKBINARY_TRADEADDENDUM_H_ +#ifndef _IL3_TRADEADDENDUM_H_ +#define _IL3_TRADEADDENDUM_H_ #if defined(SBE_HAVE_CMATH) /* cmath needed for std::numeric_limits::quiet_NaN() */ @@ -87,7 +87,7 @@ #define SBE_NULLVALUE_UINT64 (std::numeric_limits::max)() -namespace iLinkBinary { +namespace il3 { class TradeAddendum {