messages.hpp

Go to the documentation of this file.

#ifndef ISIMUD_EXCHANGES_FIX_5_0sp2_MESSAGES_HPP
#define ISIMUD_EXCHANGES_FIX_5_0sp2_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 "types.hpp"
#include "../common/messages.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 <iosfwd>
 
/**
   FIX documentation:
   -# <a href="https://www.fixtrading.org/standards/fix-5-0-sp-2/">"FIX 5.0 Specification Service Pack 2"</a>..
   -# <a href="https://github.com/jamesdbrock/hffix/commit/d2539d5602672e596c0bb34e1fe642918df7b14f">Usge of the XML specification to generate code</a>.
 
   Note that Wireshark has a built-in FIX protocol: see the "Analyze/Enabled Protocols..." dialog in Wireshark. See <a href="https://www.wireshark.org/docs/dfref/f/fix.html"/> also.
*/
namespace isimud { namespace ISIMUD_VER_NAMESPACE { namespace exchanges { namespace FIX { namespace v5_0sp2 {
 
struct VersionSpecific {
   static inline constexpr const common::underlying_fix_data_buffer::value_type fix_template_to_msg_type[]=JMMCG_FIX_v5_0sp2_MSG_VER JMMCG_FIX_MSG_BODY_LENGTH_TAG JMMCG_FIX_MSG_BODY_LENGTH_NULL JMMCG_FIX_MSG_TYPE_TAG;
   enum : std::size_t {
      fix_template_body_length_offset=sizeof(JMMCG_FIX_v5_0sp2_MSG_VER)-1+libjmmcg::enum_tags::mpl::to_array<common::FieldsFast, common::FieldsFast::BodyLength>::size,
      fix_template_msg_type_offset=sizeof(fix_template_to_msg_type)-1
   };
   static inline constexpr const char MsgVer[]=JMMCG_FIX_v5_0sp2_MSG_VER;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static constexpr bool is_valid(Msg const &m) noexcept(true);
};
 
struct LogonSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::Logon>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct LogoutRequestSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::Logout>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct HeartbeatSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::Heartbeat>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true) __attribute__((pure));
};
 
struct ServerHeartbeat : common::Message<HeartbeatSpecific> {
   using base_t=common::Message<HeartbeatSpecific>;
 
   ServerHeartbeat()
   : base_t() {
      pointer data=this->set_header<common::MsgTypes::Heartbeat>();
      this->finalise_msg(data);
   }
};
 
struct NewOrderSingleSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::NewOrderSingle>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct OrderCancelRequestSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::OrderCancelRequest>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct OrderCancelReplaceSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::OrderCancelReplaceRequest>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct ExecutionReportSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::ExecutionReport>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct LogonReplySpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::Logon>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct LogoutSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::Logout>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct CancelOrderSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::OrderCancelRequest>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct BusinessMessageRejectSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::BusinessMessageReject>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct ModifyOrderSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::OrderCancelReplaceRequest>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct TradeCaptureReportSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::TradeCaptureReport>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct TradeCaptureReportRequestSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::TradeCaptureReportRequest>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct OrderAcknowledgementSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::ExecutionAck>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct OrderRejectedSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::Reject>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct OrderModifiedSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::ExecutionReport>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct OrderRestatedSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::ExecutionReport>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct UserModifyRejectedSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::Reject>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct OrderCancelledSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::ExecutionReport>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct CancelRejectedSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::OrderCancelReject>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct OrderExecutionSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::ExecutionReport>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct TradeCaptureReportAckSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::TradeCaptureReportAck>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct TradeCaptureReportRequestAckSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::TradeCaptureReportRequestAck>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
struct RejectSpecific : public VersionSpecific {
   using msg_type=libjmmcg::enum_tags::mpl::to_array<common::MsgTypes, common::MsgTypes::Reject>;
 
   /// Verify that the referenced FIX message is valid.
   /**
      \param   m  A wrapper for the FIX message,
      \return  True is the referenced FIX message is valid, false otherwise.
   */
   template<class Msg>
   static bool is_valid(Msg const &m) noexcept(true);
};
 
/**
   I expect that the FIX message will be constructible using accessors, but also via placement-new or a reference to the data-block. I also expect that a FIX message can be constructed from BATS or MIT messages. Also BATS & MIT messages will be constructible from FIX messages.
*/
struct MsgTypes {
 
   struct ref_data {};
   using FieldsFast=common::FieldsFast;
   using field_str_const_range_t=common::field_str_const_range_t;
 
   using MsgTypes_t=common::MsgTypes_t;
   using MsgType_t=common::MsgTypes;
   using UserName_t=common::UserName_t;
   using Password_t=common::Password_t;
   using SeqNum_t=common::SeqNum_t;
   using Price_t=common::Price_t;
   using Quantity_t=common::Quantity_t;
   using Side=common::Side;
   using ClientOrderID_t=common::ClientOrderID_t;
   using SecurityID_t=common::SecurityID_t;
   using ExecType=common::ExecType;
   using TIF=common::TIF;
   using OrderType=common::OrderType;
   struct logon_args_t {};
 
   using LogonRequest=common::Message<LogonSpecific>;
   using Header_t=LogonRequest::Header_t;
   using LogoutRequest=common::Message<LogoutRequestSpecific>;
   using ClientHeartbeat=common::Message<HeartbeatSpecific>;
   using ServerHeartbeat=v5_0sp2::ServerHeartbeat;
   using NewOrderSingle=common::Message<NewOrderSingleSpecific>;
   using OrderCancelRequest=common::Message<OrderCancelRequestSpecific>;
   using OrderCancelReplace=common::Message<OrderCancelReplaceSpecific>;
   using ExecutionReport=common::Message<ExecutionReportSpecific>;
   using LogonReply=common::Message<LogonReplySpecific>;
   using Logout=common::Message<LogoutSpecific>;
   using CancelOrder=common::Message<CancelOrderSpecific>;
   using ModifyOrder=common::Message<ModifyOrderSpecific>;
   using TradeCaptureReport=common::Message<TradeCaptureReportSpecific>;
   using TradeCaptureReportRequest=common::Message<TradeCaptureReportRequestSpecific>;
   using OrderAcknowledgement=common::Message<OrderAcknowledgementSpecific>;
   using OrderRejected=common::Message<OrderRejectedSpecific>;
   using BusinessMessageReject=common::Message<BusinessMessageRejectSpecific>;
   using OrderModified=common::Message<OrderModifiedSpecific>;
   using OrderRestated=common::Message<OrderRestatedSpecific>;
   using UserModifyRejected=common::Message<UserModifyRejectedSpecific>;
   using OrderCancelled=common::Message<OrderCancelledSpecific>;
   using CancelRejected=common::Message<CancelRejectedSpecific>;
   using OrderExecution=common::Message<OrderExecutionSpecific>;
   using TradeCaptureReportAck=common::Message<TradeCaptureReportAckSpecific>;
   using TradeCaptureReportRequestAck=common::Message<TradeCaptureReportRequestAckSpecific>;
   using Reject=common::Message<RejectSpecific>;
 
   using NewOrder_t=NewOrderSingle;
 
   static inline constexpr MsgType_t MatchAll=MsgType_t::MatchAll;   ///< For the meta-state machine to allow a catch-all rule to reject anything unhandled.
   static inline constexpr MsgType_t Exit=MsgType_t::Exit;  ///< For the meta-state machine: the exit state to exit the msm.
 
   using client_to_exchange_messages_t=boost::mpl::vector<
      LogonRequest,
      LogoutRequest,
      ClientHeartbeat,
      NewOrder_t,
      OrderCancelRequest,
      OrderCancelReplace,
      ModifyOrder,
      TradeCaptureReport,
      TradeCaptureReportRequest
   >;
   using exchange_to_client_messages_t=boost::mpl::vector<
      LogonReply,
      Logout,
      ServerHeartbeat,
      OrderAcknowledgement,
      ExecutionReport,
      OrderRejected,
      BusinessMessageReject,
      OrderModified,
      OrderRestated,
      UserModifyRejected,
      OrderCancelled,
      CancelRejected,
      OrderExecution,
      TradeCaptureReportAck,
      TradeCaptureReportRequestAck,
      Reject
   >;
   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=Header_t::header_t_size
   };
   BOOST_MPL_ASSERT_RELATION(max_msg_size, >=, header_t_size);
 
   using underlying_fix_data_buffer=common::underlying_fix_data_buffer;
   using msg_buffer_t=std::array<underlying_fix_data_buffer::value_type, 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 std::uint64_t implied_decimal_places=common::implied_decimal_places;
 
   static std::ostream &to_stream(std::ostream &) noexcept(false);
};
 
/**
   \test FIX v5.0sp2 size tests.
*/
namespace tests {
 
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::Header_t), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::LogonRequest), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::LogoutRequest), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::ClientHeartbeat), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::ServerHeartbeat), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::NewOrder_t), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::OrderCancelRequest), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::OrderCancelReplace), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::ExecutionReport), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::ModifyOrder), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::TradeCaptureReport), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::TradeCaptureReportRequest), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::LogonReply), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::Logout), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::OrderAcknowledgement), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::OrderRejected), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::BusinessMessageReject), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::OrderModified), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::OrderRestated), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::UserModifyRejected), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::OrderCancelled), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::CancelRejected), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::OrderExecution), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::TradeCaptureReportAck), ==, 576);
BOOST_MPL_ASSERT_RELATION(sizeof(MsgTypes::TradeCaptureReportRequestAck), ==, 576);
 
}
 
} } } } }
 
#include "messages_impl.hpp"
 
#endif