messages.hpp

Go to the documentation of this file.

#ifndef ISIMUD_EXCHANGES_BATSBOE_common_MESSAGES_HPP
#define ISIMUD_EXCHANGES_BATSBOE_common_MESSAGES_HPP
 
/******************************************************************************
** Copyright © 2015 by J.M.McGuiness, isimud@hussar.me.uk
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
 
#include "types.hpp"
#include "optional_field_types.hpp"
 
#include "../../common/iso_10383_mic_codes.hpp"
 
#include "core/memops.hpp"
 
#include <chrono>
 
namespace isimud { namespace ISIMUD_VER_NAMESPACE { namespace exchanges { namespace BATSBOE {
 
/**
   From <a href="http://cdn.batstrading.com/resources/participant_resources/BATS_Europe_Binary_Order_Entry_Specification.pdf>"BATS Chi-X Europe Binary Order Entry Specification", Version 1.44, 27 November, 2014</a>
*/
namespace common {
 
const uint16_t msg_start_code=0xBABA;
struct logon_args_t {
   const SeqNum_t sequenceNumber{};
   const SessionSubID_t sessionSubID{};
   const UserName_t username{{}};
   const Password_t password{{}};
   const bool noUnspec{};
};
struct logoff_args_t {
   const SeqNum_t sequenceNumber{};
};
 
/**
   Section: "3.1.1 Login Request"
*/
template<class MsgT, MsgT Msg>
class Header {
public:
   using MsgType_t=MsgT;
   using MsgTypes_t=common::MsgType_t;
   enum : typename std::underlying_type<MsgType_t>::type {
      static_type=static_cast<typename std::underlying_type<MsgType_t>::type>(Msg)
   };
   enum : bool {
      has_static_size=false   ///< The message is dynamically-sized, not statically, so sizeof(MsgT) is the maximum amount to copy, but it could be less, given by length().
   };
 
   const std::uint16_t start_of_message=msg_start_code;
 
protected:
   std::uint16_t length_;
 
public:
   const MsgType_t type_{Msg};
   const std::uint8_t matchingUnit=0;
   const SeqNum_t sequenceNumber;
 
   explicit Header(std::size_t l) noexcept(true) FORCE_INLINE;
   Header(std::size_t l, SeqNum_t seqNumber) noexcept(true) FORCE_INLINE;
 
   const MsgType_t type() const noexcept(true) {
      return type_;
   }
 
   /// The actual, not the foolish BATSBOE-specified, length which excludes the start_of_message field.
   std::uint16_t length() const noexcept(true);
 
   bool is_valid() const noexcept(true) {
      return start_of_message==msg_start_code
         && length()>=sizeof(Header)
         && matchingUnit==0;
   }
 
protected:
   ~Header() noexcept(true)=default;
} __attribute__((packed));
 
/**
   Section: "3.1.1 Login Request"
*/
template<class MsgT, MsgT Msg>
struct LogonRequest : public Header<MsgT, Msg> {
   using Header_t=Header<MsgT, Msg>;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
 
   const SessionSubID_t sessionSubID;
   const UserName_t userName;
   const Password_t password;
   const uint8_t noUnspecifiedUnitReplay;
   optional::LogonTypes::OrderAcknowledgement::bitfields orderAcknowledgement_bitfields;
   optional::LogonTypes::OrderRejected::bitfields orderRejected_bitfields;
   optional::LogonTypes::OrderModified::bitfields orderModified_bitfields;
   optional::LogonTypes::OrderRestated::bitfields orderRestated_bitfields;
   const optional::LogonTypes::UserModifyRejected::bitfields userModifyRejected_bitfields;
   optional::LogonTypes::OrderCancelled::bitfields orderCancelled_bitfields;
   optional::LogonTypes::OrderExecution::bitfields orderExecution_bitfields;
   optional::LogonTypes::TradeCancelCorrect::bitfields tradeCancelCorrect_bitfields;
   optional::LogonTypes::Reserved::bitfields reserved_bitfields;
   optional::LogonTypes::TradeCaptureReportAck::bitfields tradeCaptureReportAck_bitfields;
   optional::LogonTypes::TradeCaptureReportRej::bitfields tradeCaptureReportRej_bitfields;
   optional::LogonTypes::TradeCaptureConfirm::bitfields tradeCaptureConfirm_bitfields;
   optional::LogonTypes::TradeCaptureDecline::bitfields tradeCaptureDecline_bitfields;
   const uint8_t reserved[128]={0};
   const uint8_t numberOfUnits=0;
 
   LogonRequest(SeqNum_t seqNum, const SessionSubID_t sessionSubID, const UserName_t &UN, const Password_t &P, const bool noUnspec) noexcept(true) FORCE_INLINE;
   explicit LogonRequest(logon_args_t const &a) noexcept(true) FORCE_INLINE;
 
   /// Create a message from the source message.
   /**
      If an error is generated, then this function will need to be specialised for the particular Msg-type.
 
      \param   msg   The source message from which the target message should be created.
   */
   template<class SrcMsg> __stdcall
   LogonRequest(SrcMsg const &msg, SeqNum_t seqNum, const SessionSubID_t sessionSubID, const bool noUnspec)=delete FORCE_INLINE;
} __attribute__((packed));
 
/**
   Section: "3.1.2 Logout request"
*/
struct LogoutRequest : public Header<MsgType, MsgType::LogoutRequest> {
   using Header_t=Header<MsgType, MsgType::LogoutRequest>;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
 
   explicit LogoutRequest(SeqNum_t seqNum) noexcept(true) FORCE_INLINE;
   explicit LogoutRequest(logoff_args_t const &a) noexcept(true) FORCE_INLINE;
 
   /// Create a message from the source message.
   /**
      If an error is generated, then this function will need to be specialised for the particular Msg-type.
 
      \param   msg   The source message from which the target message should be created.
   */
   template<class SrcMsg> explicit __stdcall
   LogoutRequest(SrcMsg const &msg, SeqNum_t seqNum) noexcept(true)=delete FORCE_INLINE;
} __attribute__((packed));
 
/**
   Section: "3.1.3 Client Heartbeat" & "2.4 Heartbeats".
*/
struct ClientHeartbeat : public Header<MsgType, MsgType::ClientHeartbeat> {
   using Header_t=Header<MsgType, MsgType::ClientHeartbeat>;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
   enum : common::Quantity_t {
      seq_num=0
   };
 
   explicit ClientHeartbeat(SeqNum_t seqNum) noexcept(true) FORCE_INLINE;
 
   /// Create a message from the source message.
   /**
      If an error is generated, then this function will need to be specialised for the particular Msg-type.
 
      \param   msg   The source message from which the target message should be created.
   */
   template<class SrcMsg> explicit __stdcall
   ClientHeartbeat(SrcMsg const &msg, SeqNum_t seqNum) noexcept(true)=delete FORCE_INLINE;
} __attribute__((packed));
 
/**
   Section: "3.2.1 Login Response"
*/
template<class MsgT, MsgT Msg>
struct LogonReply : public Header<MsgT, Msg> {
   using Header_t=Header<MsgT, Msg>;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
   /// Allow a client connected to the exchange to process the LogonReply message.
   struct respond;
 
   static inline constexpr const LoginResponseStatus logon_success=LoginResponseStatus::LoginAccepted;
 
   LoginResponseStatus loginResponseStatus;
 
   LogonReply() noexcept(true) FORCE_INLINE;
   explicit LogonReply(SeqNum_t seqNum) noexcept(true) FORCE_INLINE;
 
   LoginResponseStatus rejectCode() const noexcept(true) FORCE_INLINE {
      return loginResponseStatus;
   }
   void rejectCode(LoginResponseStatus const &rc) noexcept(true) FORCE_INLINE {
      loginResponseStatus=rc;
   }
} __attribute__((packed));
 
/**
   Section: "3.2.2 Logout"
*/
struct Logout : public Header<MsgType, MsgType::Logout> {
   using Header_t=Header<MsgType, MsgType::Logout>;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
 
   LogoutReason logoutReason;
   LogoutReasonText_t logoutReasonText;
   common::SeqNum_t lastReceivedSequenceNumber;
   const uint8_t numberOfUnits=0;
 
   Logout() noexcept(true) FORCE_INLINE;
   Logout(SeqNum_t seqNum, LogoutReason lr) noexcept(true) FORCE_INLINE;
} __attribute__((packed));
 
/**
   Section: "3.2.3 Server Heartbeat" & "2.4 Heartbeats".
*/
struct ServerHeartbeat : public Header<MsgType, MsgType::ServerHeartbeat> {
   using Header_t=Header<MsgType, MsgType::ServerHeartbeat>;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
   enum : common::Quantity_t {
      seq_num=0
   };
 
   explicit ServerHeartbeat(SeqNum_t seqNum) noexcept(true) FORCE_INLINE;
 
   /// Create a message from the source message.
   /**
      If an error is generated, then this function will need to be specialised for the particular Msg-type.
 
      \param   msg   The source message from which the target message should be created.
   */
   template<class SrcMsg> explicit __stdcall
   ServerHeartbeat(SrcMsg const &msg, SeqNum_t seqNum) noexcept(true)=delete FORCE_INLINE;
} __attribute__((packed));
 
/**
   Section: "3.2.4 Replay Complete"
*/
struct ReplayComplete : public Header<MsgType, MsgType::ReplayComplete> {
   using Header_t=Header<MsgType, MsgType::ReplayComplete>;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
 
   explicit ReplayComplete(SeqNum_t seqNum) noexcept(true) FORCE_INLINE;
} __attribute__((packed));
 
/**
   Section: "4.1.1 New Order"
*/
struct NewOrder : public Header<MsgType, MsgType::NewOrder> {
   using Header_t=Header<MsgType, MsgType::NewOrder>;
   using bitfields_to_type_map=optional::NewOrder::bitfields_to_type_map;
   using bitfields_tags_type=bitfields_to_type_map::bitfields_tags_type;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
 
   explicit NewOrder(SeqNum_t seqNum, ClientOrderID_t const &clID, OrdType const oT, TIF const t, Side const s, SecurityID_t instID, common::Quantity_t ordQty, Price_t p) noexcept(true) FORCE_INLINE;
   /// Create a message from the source message.
   /**
      If an error is generated, then this function will need to be specialised for the particular Msg-type.
 
      \param   msg   The source message from which the target message should be created.
   */
   template<class SrcMsg> explicit __stdcall
   NewOrder(SrcMsg const &msg, SeqNum_t seqNum) noexcept(true)=delete FORCE_INLINE;
 
   ClientOrderID_t const &clientOrderID() const noexcept(true) {
      return clientOrderID_;
   }
   void clientOrderID(ClientOrderID_t const &clID) noexcept(true) {
      libjmmcg::memcpy_opt(clID, clientOrderID_);
   }
 
   common::Quantity_t orderQty() const noexcept(true) {
      return orderQty_;
   }
   void orderQty(common::Quantity_t i) noexcept(true) {
      orderQty_=i;
   }
 
   OrdType const &orderType() const noexcept(true);
   void orderType(OrdType const &i) noexcept(true);
 
   common::Side side() const noexcept(true) {
      return side_;
   }
   void side(common::Side i) noexcept(true) {
      side_=i;
   }
 
   SecurityID_t const &instrumentID() const noexcept(true);
   void instrumentID(SecurityID_t const &i) noexcept(true);
 
   Price_t limitPrice() const noexcept(true);
   void limitPrice(Price_t p) noexcept(true);
 
   TIF tif() const noexcept(true);
   void tif(TIF t) noexcept(true);
 
private:
   ClientOrderID_t clientOrderID_;
   common::Side side_;
   common::Quantity_t orderQty_;
   bitfields_to_type_map bitfields;
} __attribute__((packed));
 
/**
   Section: "4.1.2 Cancel Order"
*/
struct CancelOrder : public Header<MsgType, MsgType::CancelOrder> {
   using Header_t=Header<MsgType, MsgType::CancelOrder>;
   using bitfields_to_type_map=optional::CancelOrder::bitfields_to_type_map;
   using bitfields_tags_type=bitfields_to_type_map::bitfields_tags_type;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
 
   CancelOrder(SeqNum_t seqNum, ClientOrderID_t const &origclID) noexcept(true) FORCE_INLINE;
   /// Create a message from the source message.
   /**
      If an error is generated, then this function will need to be specialised for the particular Msg-type.
 
      \param   msg   The source message from which the target message should be created.
   */
   template<class SrcMsg> __stdcall
   CancelOrder(SrcMsg const &msg, SeqNum_t seqNum) noexcept(true)=delete FORCE_INLINE;
 
   ClientOrderID_t const &originalClientOrderID() const noexcept(true) {
      return originalClientOrderID_;
   }
   void originalClientOrderID(ClientOrderID_t const &origclID) noexcept(true) {
      libjmmcg::memcpy_opt(origclID, originalClientOrderID_);
   }
 
private:
   ClientOrderID_t originalClientOrderID_;
   bitfields_to_type_map bitfields;
} __attribute__((packed));
 
/**
   Section: "4.1.3 Modify Order"
*/
struct ModifyOrder : public Header<MsgType, MsgType::ModifyOrder> {
   using Header_t=Header<MsgType, MsgType::ModifyOrder>;
   using bitfields_to_type_map=optional::ModifyOrder::bitfields_to_type_map;
   using bitfields_tags_type=bitfields_to_type_map::bitfields_tags_type;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
 
   ModifyOrder(SeqNum_t seqNum, ClientOrderID_t const &clID, common::Quantity_t ordQty, Price_t p, Side s) noexcept(true) FORCE_INLINE;
 
   /// Create a message from the source message.
   /**
      If an error is generated, then this function will need to be specialised for the particular Msg-type.
 
      \param   msg   The source message from which the target message should be created.
   */
   template<class SrcMsg> explicit __stdcall
   ModifyOrder(SrcMsg const &msg, SeqNum_t seqNum) noexcept(true)=delete FORCE_INLINE;
 
   ClientOrderID_t const &originalClientOrderID() const noexcept(true) {
      return originalClientOrderID_;
   }
   void originalClientOrderID(ClientOrderID_t const &clID) noexcept(true) {
      libjmmcg::memcpy_opt(clID, originalClientOrderID_);
   }
 
   Price_t limitPrice() const noexcept(true);
   void limitPrice(Price_t p) noexcept(true);
 
   common::Quantity_t orderQty() const noexcept(true);
   void orderQty(common::Quantity_t i) noexcept(true);
 
   Side side() const noexcept(true);
   void side(Side i) noexcept(true);
 
private:
   ClientOrderID_t clientOrderID_;
   ClientOrderID_t originalClientOrderID_;
   bitfields_to_type_map bitfields;
} __attribute__((packed));
 
/**
   Section: "4.2.1 Order Acknowledgement"
*/
struct OrderAcknowledgement : public Header<MsgType, MsgType::OrderAcknowledgement> {
   using Header_t=Header<MsgType, MsgType::OrderAcknowledgement>;
   using bitfields_to_type_map=optional::OrderAcknowledgement::bitfields_to_type_map;
   using bitfields_tags_type=bitfields_to_type_map::bitfields_tags_type;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
 
   const DateTime_t transactionTime;
 
   explicit OrderAcknowledgement(SeqNum_t seqNum, ClientOrderID_t const &clID) noexcept(true) FORCE_INLINE;
 
   ClientOrderID_t const &clientOrderID() const noexcept(true) {
      return clientOrderID_;
   }
   void clientOrderID(ClientOrderID_t const &clID) noexcept(true) {
      libjmmcg::memcpy_opt(clID, clientOrderID_);
   }
 
private:
   ClientOrderID_t clientOrderID_;
   uint64_t orderID;
   bitfields_to_type_map bitfields;
} __attribute__((packed));
 
/**
   Section: "4.2.2 Order Rejected"
*/
struct OrderRejected : public Header<MsgType, MsgType::OrderRejected> {
   using Header_t=Header<MsgType, MsgType::OrderRejected>;
   using bitfields_to_type_map=optional::OrderRejected::bitfields_to_type_map;
   using bitfields_tags_type=bitfields_to_type_map::bitfields_tags_type;
   using RejectCode_t=int;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
   static inline constexpr const OrderRejectReason unknown_msg=OrderRejectReason::UnforeseenReason;
 
   const DateTime_t transactionTime;
 
   OrderRejected() noexcept(true) FORCE_INLINE;
   OrderRejected(SeqNum_t seqNum, ClientOrderID_t const &clID, OrderRejectReason orr) noexcept(true) FORCE_INLINE;
 
   ClientOrderID_t const &clientOrderID() const noexcept(true) {
      return clientOrderID_;
   }
   void clientOrderID(ClientOrderID_t const &clID) noexcept(true) {
      libjmmcg::memcpy_opt(clID, clientOrderID_);
   }
 
private:
   ClientOrderID_t clientOrderID_;
 
public:
   const OrderRejectReason orderRejectReason;
 
private:
   Text_t text;
   bitfields_to_type_map bitfields;
} __attribute__((packed));
 
/**
   Section: "4.2.3 Order Modified"
*/
struct OrderModified : public Header<MsgType, MsgType::OrderModified> {
   using Header_t=Header<MsgType, MsgType::OrderModified>;
   using bitfields_to_type_map=optional::OrderModified::bitfields_to_type_map;
   using bitfields_tags_type=bitfields_to_type_map::bitfields_tags_type;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
 
   const DateTime_t transactionTime;
 
   explicit OrderModified() noexcept(true) FORCE_INLINE;
   explicit OrderModified(SeqNum_t seqNum, ClientOrderID_t const &clID, Price_t p, Side s, common::Quantity_t ordQty) noexcept(true) FORCE_INLINE;
 
   ClientOrderID_t const &clientOrderID() const noexcept(true) {
      return clientOrderID_;
   }
   void clientOrderID(ClientOrderID_t const &clID) noexcept(true) {
      libjmmcg::memcpy_opt(clID, clientOrderID_);
   }
 
   Price_t limitPrice() const noexcept(true);
   void limitPrice(Price_t p) noexcept(true);
 
   common::Quantity_t orderQty() const noexcept(true);
   void orderQty(common::Quantity_t i) noexcept(true);
 
   Side side() const noexcept(true);
   void side(Side i) noexcept(true);
 
private:
   ClientOrderID_t clientOrderID_;
   uint64_t orderID;
   bitfields_to_type_map bitfields;
} __attribute__((packed));
 
/**
   Section: "4.2.4 Order Restated"
*/
struct OrderRestated : public Header<MsgType, MsgType::OrderRestated> {
   using Header_t=Header<MsgType, MsgType::OrderRestated>;
   using bitfields_to_type_map=optional::OrderRestated::bitfields_to_type_map;
   using bitfields_tags_type=bitfields_to_type_map::bitfields_tags_type;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
 
   const DateTime_t transactionTime;
 
   explicit OrderRestated(SeqNum_t seqNum, ClientOrderID_t const &clID) noexcept(true) FORCE_INLINE;
 
   ClientOrderID_t const &clientOrderID() const noexcept(true) {
      return clientOrderID_;
   }
   void clientOrderID(ClientOrderID_t const &clID) noexcept(true) {
      libjmmcg::memcpy_opt(clID, clientOrderID_);
   }
 
private:
   ClientOrderID_t clientOrderID_;
   uint64_t orderID;
   RestatementReason restatementReason;
   bitfields_to_type_map bitfields;
} __attribute__((packed));
 
/**
   Section: "4.2.5 User Modify Rejected"
*/
struct UserModifyRejected : public Header<MsgType, MsgType::UserModifyRejected> {
   using Header_t=Header<MsgType, MsgType::UserModifyRejected>;
   using bitfields_to_type_map=optional::UserModifyRejected::bitfields_to_type_map;
   using bitfields_tags_type=bitfields_to_type_map::bitfields_tags_type;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
 
   const DateTime_t transactionTime;
 
   UserModifyRejected() noexcept(true) FORCE_INLINE;
   explicit UserModifyRejected(SeqNum_t seqNum, ClientOrderID_t const &clID, OrderRejectReason orr) noexcept(true) FORCE_INLINE;
 
   ClientOrderID_t const &clientOrderID() const noexcept(true) {
      return clientOrderID_;
   }
   void clientOrderID(ClientOrderID_t const &clID) noexcept(true) {
      libjmmcg::memcpy_opt(clID, clientOrderID_);
   }
 
private:
   ClientOrderID_t clientOrderID_;
   uint64_t orderID;
 
public:
   const OrderRejectReason modifyRejectReason;
 
private:
   Text_t text;
   bitfields_to_type_map bitfields;
} __attribute__((packed));
 
/**
   Section: "4.2.6 Order Cancelled"
*/
struct OrderCancelled : public Header<MsgType, MsgType::OrderCancelled> {
   using Header_t=Header<MsgType, MsgType::OrderCancelled>;
   using bitfields_to_type_map=optional::OrderCancelled::bitfields_to_type_map;
   using bitfields_tags_type=bitfields_to_type_map::bitfields_tags_type;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
 
   const DateTime_t transactionTime;
 
   explicit OrderCancelled() noexcept(true) FORCE_INLINE;
   explicit OrderCancelled(SeqNum_t seqNum, ClientOrderID_t const &clID, OrderRejectReason orr, Price_t p, Side s, common::Quantity_t ls, common::Quantity_t ordQty) noexcept(true) FORCE_INLINE;
 
   ClientOrderID_t const &clientOrderID() const noexcept(true) {
      return clientOrderID_;
   }
   void clientOrderID(ClientOrderID_t const &clID) noexcept(true) {
      libjmmcg::memcpy_opt(clID, clientOrderID_);
   }
 
   Side side() const noexcept(true);
 
   common::Quantity_t orderQty() const noexcept(true);
 
   common::Quantity_t leavesQty() const noexcept(true);
 
   common::Quantity_t lastShares() const noexcept(true);
 
   Price_t lastPrice() const noexcept(true);
 
private:
   ClientOrderID_t clientOrderID_;
 
public:
   const OrderRejectReason cancelReason;
 
private:
   bitfields_to_type_map bitfields;
} __attribute__((packed));
 
/**
   Section: "4.2.7 Cancel Rejected"
*/
struct CancelRejected : public Header<MsgType, MsgType::CancelRejected> {
   using Header_t=Header<MsgType, MsgType::CancelRejected>;
   using bitfields_to_type_map=optional::CancelRejected::bitfields_to_type_map;
   using bitfields_tags_type=bitfields_to_type_map::bitfields_tags_type;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
 
   const DateTime_t transactionTime;
 
   CancelRejected() noexcept(true) FORCE_INLINE;
   CancelRejected(SeqNum_t seqNum, ClientOrderID_t const &clID, OrderRejectReason crr) noexcept(true) FORCE_INLINE;
 
   ClientOrderID_t const &clientOrderID() const noexcept(true) {
      return clientOrderID_;
   }
   void clientOrderID(ClientOrderID_t const &clID) noexcept(true) {
      libjmmcg::memcpy_opt(clID, clientOrderID_);
   }
 
private:
   ClientOrderID_t clientOrderID_;
 
public:
   const OrderRejectReason cancelRejectReason;
 
private:
   Text_t text;
   bitfields_to_type_map bitfields;
} __attribute__((packed));
 
/**
   Section: "4.2.8 Order Execution"
*/
struct OrderExecution : public Header<MsgType, MsgType::OrderExecution> {
   using Header_t=Header<MsgType, MsgType::OrderExecution>;
   using bitfields_to_type_map=optional::OrderExecution::bitfields_to_type_map;
   using bitfields_tags_type=bitfields_to_type_map::bitfields_tags_type;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
 
   const DateTime_t transactionTime;
 
   OrderExecution() noexcept(true) FORCE_INLINE;
   OrderExecution(SeqNum_t seqNum, ClientOrderID_t const &clID, Price_t const price, SecurityID_t const &instID, Side s) noexcept(true) FORCE_INLINE;
 
   ClientOrderID_t const &clientOrderID() const noexcept(true) {
      return clientOrderID_;
   }
   void clientOrderID(ClientOrderID_t const &clID) noexcept(true) {
      libjmmcg::memcpy_opt(clID, clientOrderID_);
   }
 
   SecurityID_t const &instrumentID() const noexcept(true);
   void instrumentID(SecurityID_t const &i) noexcept(true);
 
   Price_t executedPrice() const noexcept(true) {
      return lastPx;
   }
   void executedPrice(Price_t p) noexcept(true) {
      lastPx=p;
   }
 
   common::Quantity_t executedQty() const noexcept(true) {
      return lastShares;
   }
   void executedQty(common::Quantity_t eq) noexcept(true) {
      lastShares=eq;
   }
 
   common::Quantity_t leavesQty() const noexcept(true) {
      return leavesQty_;
   }
   void leavesQty(common::Quantity_t eq) noexcept(true) {
      leavesQty_=eq;
   }
 
   Side side() const noexcept(true);
   void side(Side s) noexcept(true);
 
private:
   ClientOrderID_t clientOrderID_;
   uint64_t execID;
   common::Quantity_t lastShares;
   Price_t lastPx;
   common::Quantity_t leavesQty_;
   BaseLiquidityIndicator baseLiquidityIndicator;
   SubLiquidityIndicator subLiquidityIndicator;
   SPrice_t accessFee;
   ContraBroker_t contraBroker;
   bitfields_to_type_map bitfields;
} __attribute__((packed));
 
/**
   Section: "4.2.9 Trade Cancel or Correct"
*/
struct TradeCancelOrCorrect : public Header<MsgType, MsgType::TradeCancelOrCorrect> {
   using Header_t=Header<MsgType, MsgType::TradeCancelOrCorrect>;
   using bitfields_to_type_map=optional::TradeCancelOrCorrect::bitfields_to_type_map;
   using bitfields_tags_type=bitfields_to_type_map::bitfields_tags_type;
   enum : std::size_t {
      header_t_size=sizeof(Header_t)
   };
 
   const DateTime_t transactionTime;
 
   explicit TradeCancelOrCorrect(SeqNum_t seqNum, ClientOrderID_t const &clID) noexcept(true) FORCE_INLINE;
 
   ClientOrderID_t const &clientOrderID() const noexcept(true) {
      return clientOrderID_;
   }
   void clientOrderID(ClientOrderID_t const &clID) noexcept(true) {
      libjmmcg::memcpy_opt(clID, clientOrderID_);
   }
 
private:
   ClientOrderID_t clientOrderID_;
   uint64_t orderID;
   uint64_t execRefID;
   Side side;
   BaseLiquidityIndicator baseLiquidityIndicator;
   ClearingFirm_t clearingFirm;
   ClearingAccount_t clearingAccount;
   Quantity_t lastShares;
   Price_t lastPx;
   Price_t correctedPrice;
   DateTime_t origTime;
   bitfields_to_type_map bitfields;
} __attribute__((packed));
 
} } } } }
 
#include "messages_impl.hpp"
 
#endif