messages.hpp

Go to the documentation of this file.

#ifndef ISIMUD_EXCHANGES_MIT_OSLO_MESSAGES_HPP
#define ISIMUD_EXCHANGES_MIT_OSLO_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 "config.h"
#include "reject_codes.hpp"
 
#include "../common/messages.hpp"
#include "../common/ref_data.hpp"
 
#include "core/max_min.hpp"
 
#include <boost/mpl/assert.hpp>
#include <boost/mpl/deref.hpp>
#include <boost/mpl/max_element.hpp>
#include <boost/mpl/min_element.hpp>
#include <boost/mpl/placeholders.hpp>
#include <boost/mpl/sizeof.hpp>
#include <boost/mpl/transform_view.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/variant/variant.hpp>
 
#include <iostream>
 
namespace isimud { namespace ISIMUD_VER_NAMESPACE { namespace exchanges { namespace MIT {
 
/**
   See:
   -# <a href="https://www.oslobors.no/ob_eng/Oslo-Boers/Trading/Trading-systems/Millennium-Exchange/Technical-documentation"/>
   -# <a href="https://www.oslobors.no/obnewsletter/download/084172908123a0c01db388950fd0ecd3/file/file/OSLMIT%20203%20Native%20Trading%20Gateway%20-%20issue%205.2.pdf">"OSLMIT 203 Native Trading Gateway", Issue 5.2, 27 October 2016</a>.
   -# <a href="https://www.oslobors.no/ob_eng/obnewsletter/download/af04d9d4a7aff5dd1d2f1bf402618b4f/file/file/OSLMIT%20203%20Native%20Trading%20Gateway%20-%20issue%204.2.pdf">"Millennium Exchange - Oslo Børs cash equities and fixed income markets", OSLMIT 801 Reject Codes, Issue 4.2, 28 April 2015</a>.
 
   "OSLMIT 203 Native Trading Gateway", Issue 4.1, 12 January 2015
 
*/
namespace OSLO {
 
/**
   Section: "5.6.1 New Order"
*/
struct NewOrderSpecific1 {
   common::SecurityID_t instrumentID_;
   const std::int8_t reservedField1=0;
   const std::int8_t reservedField2=0;
 
   explicit constexpr NewOrderSpecific1(common::SecurityID_t instID) noexcept(true) FORCE_INLINE
   : instrumentID_(instID) {
   }
   common::SecurityID_t instrumentID() const noexcept(true) {
      return instrumentID_;
   }
   void instrumentID(common::SecurityID_t i) noexcept(true) {
      instrumentID_=i;
   }
} __attribute__((packed));
struct NewOrderSpecific2 {
   using order_qty_t=std::uint64_t;
 
   order_qty_t orderQty_;
   order_qty_t displayQty;
 
   explicit constexpr NewOrderSpecific2(order_qty_t ordQty) noexcept(true) FORCE_INLINE
   : orderQty_(ordQty), displayQty(ordQty) {
   }
   order_qty_t orderQty() const noexcept(true) {
      return orderQty_;
   }
   void orderQty(order_qty_t i) noexcept(true) {
      orderQty_=i;
   }
} __attribute__((packed));
struct NewOrderSpecific3 {
   common::PassiveOnlyOrder passiveOnlyOrder_=common::PassiveOnlyOrder::NoConstraint;
   common::TargetBook targetBook=common::TargetBook::LitOrderBook;
   common::ExecInstruction execInstruction=common::ExecInstruction::Default;
   int32_t minimumQuantity=0;
   const common::PegPriceType pegPriceType=common::PegPriceType::MidPoint;
   common::ReservedField12_t reservedField;
 
   common::PassiveOnlyOrder FORCE_INLINE passiveOnlyOrder() const noexcept(true) {
      return passiveOnlyOrder_;
   }
   void FORCE_INLINE passiveOnlyOrder(common::PassiveOnlyOrder poo) noexcept(true) {
      passiveOnlyOrder_=poo;
   }
   static constexpr common::OrderSource FORCE_INLINE orderSource() noexcept(true) {
      return common::OrderSource::MarketParticipantDealsOnOwnAccount;
   }
   static void FORCE_INLINE orderSource(common::OrderSource) noexcept(true) {
   }
} __attribute__((packed));
 
/**
   Section: "5.6.4 Order Modification Request"
*/
struct OrderCancelReplaceRequestSpecific {
   common::TargetBook targetBook;
   common::ExecInstruction execInstruction;
   int32_t minimumQuantity;
   const int16_t reservedField1=0;
   common::ReservedField10_t reservedField2;
   common::PassiveOnlyOrder passiveOnlyOrder_;
 
   common::PassiveOnlyOrder FORCE_INLINE passiveOnlyOrder() const noexcept(true) {
      return passiveOnlyOrder_;
   }
   void FORCE_INLINE passiveOnlyOrder(common::PassiveOnlyOrder poo) noexcept(true) {
      passiveOnlyOrder_=poo;
   }
} __attribute__((packed));
 
/**
   Section: "5.7.1 Execution Report"
*/
struct ExecutionReportSpecific1 {
   using RejectCode_t=mit_oslo::reject_codes_enum;
   using RejectCodes_t=std::underlying_type<RejectCode_t>::type;
   using order_qty_t=std::uint64_t;
 
   order_qty_t executedQty;
   order_qty_t leavesQty;
   common::Container container;
   order_qty_t displayQty;
} __attribute__((packed));
struct ExecutionReportSpecific2 {
   common::TargetBook targetBook;
   int32_t minimumQuantity;
   const std::int8_t reservedField1=0;
   common::ReservedField4_t reservedField2;
   const uint8_t reservedField3=0;
   common::Price_t avgPx;
   const common::Price_t reservedField4=0;
   common::ReservedField20_t reservedField5;
   common::TypeOfTrade typeOfTrade;
   common::ReservedField20_t reservedField6;
   common::RestatementReason restatementReason;
   common::PriceDifferential priceDifferential;
   common::OrderID_t publicOrderID;
} __attribute__((packed));
 
struct OrderMassCancelRequestSpecific1 {
   common::SecurityID_t instrumentID_;
   const std::int8_t reservedField1=0;
   const std::int8_t reservedField2=0;
   common::Segment_t segment{};
 
   explicit constexpr OrderMassCancelRequestSpecific1(common::SecurityID_t instID) noexcept(true) FORCE_INLINE
   : instrumentID_(instID) {
   }
   common::SecurityID_t instrumentID() const noexcept(true) {
      return instrumentID_;
   }
   void instrumentID(common::SecurityID_t i) noexcept(true) {
      instrumentID_=i;
   }
} __attribute__((packed));
 
struct LogonReply : public common::LogonReply<mit_oslo::reject_codes_enum> {
   using base_t=common::LogonReply<mit_oslo::reject_codes_enum>;
   using RejectCode_t=base_t::RejectCode_t;
   using RejectCodes_t=std::underlying_type<RejectCode_t>::type;
   using base_t::base_t;
 
   static inline constexpr const RejectCode_t logon_success=mit_oslo::reject_codes_enum::tag_SUCCESS;
   static inline constexpr const RejectCode_t invalid_logon_details=mit_oslo::reject_codes_enum::Native_Trading_Gateway__Invalid_User_ID_or_password_1;
   static inline constexpr const RejectCode_t unknown_user=mit_oslo::reject_codes_enum::Native_Trading_Gateway__Invalid_User_ID_or_password_1;
};
 
struct NewOrder : public common::NewOrder<NewOrderSpecific1, NewOrderSpecific2, NewOrderSpecific3> {
   using base_t=common::NewOrder<NewOrderSpecific1, NewOrderSpecific2, NewOrderSpecific3>;
   using base_t::base_t;
   using order_qty_t=NewOrderSpecific2::order_qty_t;
   using ref_data=common::ref_data;
 
   /// Create a message from the source message.
   /**
      If a linker 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, ref_data const &rd) noexcept(true) FORCE_INLINE;
} __attribute__((packed));
 
struct OrderCancelReplaceRequest : public common::OrderCancelReplaceRequest<NewOrderSpecific1, NewOrderSpecific2, OrderCancelReplaceRequestSpecific> {
   using base_t=common::OrderCancelReplaceRequest<NewOrderSpecific1, NewOrderSpecific2, OrderCancelReplaceRequestSpecific>;
   using base_t::base_t;
   using order_qty_t=NewOrderSpecific2::order_qty_t;
   using ref_data=common::ref_data;
 
   /// Create a message from the source message.
   /**
      If a linker 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
   OrderCancelReplaceRequest(SrcMsg const &msg, ref_data const &rd) noexcept(true);
} __attribute__((packed));
 
struct OrderCancelRequest : public common::OrderCancelRequest<NewOrderSpecific1> {
   using base_t=common::OrderCancelRequest<NewOrderSpecific1>;
   using base_t::base_t;
   using ref_data=common::ref_data;
 
   /// Create a message from the source message.
   /**
      If a linker 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
   OrderCancelRequest(SrcMsg const &msg, ref_data const &rd) noexcept(true);
} __attribute__((packed));
 
struct MsgTypes {
 
   static inline constexpr const exchanges::common::mic_codes::ISO_10383_MIC_Codes MIC_code=exchanges::common::mic_codes::ISO_10383_MIC_Codes::ISO_10383_NORWAY_XOSL;
 
   using ref_data=common::ref_data;
 
   using MsgTypes_t=common::MsgType_t;
   using UserName_t=common::UserName_t;
   using Password_t=common::Password_t;
   using SecurityID_t=common::SecurityID_t;
   using SeqNum_t=common::SeqNum_t;
   using Price_t=common::Price_t;
   using Quantity_t=NewOrderSpecific2::order_qty_t;
   using ClientOrderID_t=common::ClientOrderID_t;
   using OrderType=common::OrderType;
   using Side=common::Side;
   using TIF=common::TIF;
   using ExecType=common::ExecType;
   using AppID=common::AppID;
   using OrderStatus=common::OrderStatus;
   using logon_args_t=common::logon_args_t;
 
   using Header_t=common::Header;
   using NewOrder_t=OSLO::NewOrder;
   using OrderCancelRequest=OSLO::OrderCancelRequest;
   typedef common::OrderMassCancelRequest<OrderMassCancelRequestSpecific1> OrderMassCancelRequest;
   using OrderCancelReplaceRequest=OSLO::OrderCancelReplaceRequest;
   typedef common::LogonRequest LogonRequest;
   typedef common::LogoutRequest LogoutRequest;
   using ClientHeartbeat=common::Heartbeat;
   using ServerHeartbeat=common::Heartbeat;
   typedef common::MissedMessageRequest MissedMessageRequest;
   typedef common::ExecutionReport<ExecutionReportSpecific1, ExecutionReportSpecific2> ExecutionReport;
   using OrderCancelReject=common::OrderCancelReject<common::OrderCancelRejectSpecific<mit_oslo::reject_codes_enum>>;
   using OrderMassCancelReport=common::OrderMassCancelReport<common::OrderMassCancelReportSpecific<mit_oslo::reject_codes_enum>>;
   using BusinessReject=common::BusinessReject<common::BusinessRejectSpecific<mit_oslo::reject_codes_enum, mit_oslo::reject_codes_enum::Matching_Engine__Unknown_instrument_9000>>;
   using LogonReply=OSLO::LogonReply;
   typedef common::MissedMessageRequestAck MissedMessageRequestAck;
   typedef common::MissedMessageReport MissedMessageReport;
   using Reject=common::Reject<mit_oslo::reject_codes_enum, mit_oslo::reject_codes_enum::Native_Trading_Gateway__Message_not_supported_102>;
   typedef common::SystemStatus SystemStatus;
 
   using Logout=LogoutRequest;
 
   static inline constexpr MsgTypes_t MatchAll=std::numeric_limits<MsgTypes_t>::max()-1;  ///< For the meta-state machine to allow a catch-all rule to reject anything unhandled.
   static inline constexpr MsgTypes_t Exit=std::numeric_limits<MsgTypes_t>::max();  ///< For the meta-state machine: the exit state to exit the msm.
 
   using client_to_exchange_messages_t=boost::mpl::vector<
      NewOrder_t,
      OrderCancelRequest,
      OrderMassCancelRequest,
      OrderCancelReplaceRequest,
      LogonRequest,
      LogoutRequest,
      ClientHeartbeat,
      MissedMessageRequest
   >;
 
   using exchange_to_client_messages_t=boost::mpl::vector<
      ExecutionReport,
      OrderCancelReject,
      OrderMassCancelReport,
      BusinessReject,
      LogonReply,
      Logout,
      ServerHeartbeat,
      MissedMessageRequestAck,
      MissedMessageReport,
      Reject,
      SystemStatus
   >;
 
   enum : std::size_t {
      min_size_client_to_exchange_msg=sizeof(
         boost::mpl::deref<
            boost::mpl::min_element<
               boost::mpl::transform_view<client_to_exchange_messages_t, boost::mpl::sizeof_<boost::mpl::_1> >
            >::type::base
         >::type
      ),
      max_size_client_to_exchange_msg=sizeof(
         boost::mpl::deref<
            boost::mpl::max_element<
               boost::mpl::transform_view<client_to_exchange_messages_t, boost::mpl::sizeof_<boost::mpl::_1> >
            >::type::base
         >::type
      ),
      min_size_exchange_to_client_msg=sizeof(
         boost::mpl::deref<
            boost::mpl::min_element<
               boost::mpl::transform_view<exchange_to_client_messages_t, boost::mpl::sizeof_<boost::mpl::_1> >
            >::type::base
         >::type
      ),
      max_size_exchange_to_client_msg=sizeof(
         boost::mpl::deref<
            boost::mpl::max_element<
               boost::mpl::transform_view<exchange_to_client_messages_t, boost::mpl::sizeof_<boost::mpl::_1> >
            >::type::base
         >::type
      ),
      min_msg_size=libjmmcg::min<std::size_t, min_size_client_to_exchange_msg, min_size_exchange_to_client_msg>::value,
      max_msg_size=libjmmcg::max<std::size_t, max_size_client_to_exchange_msg, max_size_exchange_to_client_msg>::value,
      header_t_size=sizeof(typename LogonRequest::Header_t)
   };
   BOOST_MPL_ASSERT_RELATION(max_msg_size, >=, header_t_size);
 
   using msg_buffer_t=std::array<std::uint8_t, max_msg_size>;
   using client_to_exchange_messages_container=boost::make_variant_over<client_to_exchange_messages_t>::type;
   using exchange_to_client_messages_container=boost::make_variant_over<exchange_to_client_messages_t>::type;
 
   static inline constexpr Price_t implied_decimal_places=common::implied_decimal_places;
 
   static std::ostream &to_stream(std::ostream &) noexcept(false);
};
 
/**
   \test MIT OSLO size tests.
*/
namespace tests {
 
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::Header_t), <=, MsgTypes::max_size_client_to_exchange_msg);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::Header_t), <=, MsgTypes::max_size_exchange_to_client_msg);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::Header_t), <=, MsgTypes::max_msg_size);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::LogonRequest), ==, 80);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::LogonReply), ==, 38);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::Logout), ==, 24);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::ClientHeartbeat), ==, 4);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::ServerHeartbeat), ==, 4);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::MissedMessageRequest), ==, 9);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::MissedMessageRequestAck), ==, 5);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::MissedMessageReport), ==, 5);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::Reject), ==, 59);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::SystemStatus), ==, 6);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::NewOrder_t), ==, 106);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::OrderCancelReplaceRequest), ==, 129);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::OrderCancelRequest), ==, 73);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::OrderMassCancelRequest), ==, 46);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::ExecutionReport), ==, 229);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::OrderCancelReject), ==, 73);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::OrderMassCancelReport), ==, 56);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::BusinessReject), ==, 63);
 
}
 
} } } } }
 
#include "messages_impl.hpp"
 
#endif