TradingClient.h

Go to the documentation of this file.

/*
* Copyright Onix Solutions Limited [OnixS]. All rights reserved.
*
* This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
* and international copyright treaties.
*
* Access to and use of the software is governed by the terms of the applicable OnixS Software
* Services Agreement (the Agreement) and Customer end user license agreements granting
* a non-assignable, non-transferable and non-exclusive license to use the software
* for it's own data processing purposes under the terms defined in the Agreement.
*
* Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
* of this source code or associated reference material to any other location for further reproduction
* or redistribution, and any amendments to this copyright notice, are expressly prohibited.
*
* Any reproduction or redistribution for sale or hiring of the Software not in accordance with
* the terms of the Agreement is a violation of copyright law.
*/
#pragma once
 
#include <OnixS/ICE/BOE/IceBoe.h>
 
#include "Settings.h"
#include "CUI.h"
#include "Order.h"
#include "Book.h"
#include "Utils.h"
 
namespace Samples {
 
constexpr size_t NewOrderCrossRequestMaxEntriesCount = 2;
constexpr size_t QuoteCancelRequestMaxEntriesCount = 1;
constexpr size_t MassQuoteRequestMaxEntriesCount = 2;
 
using NewOrderCrossRequestMsg = MessageHolder<NewOrderCrossRequest, getMaxMessageSize<NewOrderCrossRequest>(NewOrderCrossRequestMaxEntriesCount)>;
using NewOrderRequestMsg = MessageHolder<NewOrderRequest>;
using SecurityDefinitionRequestMsg = MessageHolder<SecurityDefinitionRequest>;
using CancelRequestMsg = MessageHolder<CancelRequest>;
using CancelReplaceRequestMsg = MessageHolder<CancelReplaceRequest>;
using OrderMassCancelRequestMsg = MessageHolder<OrderMassCancelRequest>;
using QuoteRequestMsg = MessageHolder<QuoteRequest>;
using QuoteCancelRequestMsg = MessageHolder<QuoteCancelRequest, getMaxMessageSize<QuoteCancelRequest>(QuoteCancelRequestMaxEntriesCount)>;
using MassQuoteRequestMsg = MessageHolder<MassQuoteRequest, getMaxMessageSize<MassQuoteRequest>(MassQuoteRequestMaxEntriesCount)>;
 
class TradingClient : private SessionListener
{
public:
    explicit TradingClient(const Settings& settings);


    void connectBus();

    void requestBgwCredentials();

    void requestInstruments();

    void listInstruments();

    void lookupInstruments();

    void connectBgw();

    void traderLogon();

    void traderLogout();

    void sendOrder();

    void cancelOrder();

    void replaceOrder();

    void sendOrderCross();

    void sendMassCancel();

    void showOrders();

    void showActiveOrders();

    void sendQuote();

    void sendQuoteCancelRequest();

    void sendMassQuote();

    void createStrategy();

    void createFlex();
 
private:
    using SessionPtr = std::unique_ptr<Session>;
    using OrderBook = Book;
    using OrderId = OrderBook::BookEntryId;

    const Settings& settings_;
    const SessionSettings sessionSettings_;

    OrderBook orderBook_;
 
    BgwCredentials bgwCredentials_;

    std::vector<std::shared_ptr<std::vector<uint8_t>>> instruments_;

    std::vector<std::pair<Int32, Int32>> quoteSetId_;
    Int32 getQuoteSetId(Int32 underlyingSymbol);
 
    SessionPtr busSession_;
    SessionPtr bgwSession_;
 
    NewOrderRequestMsg newOrderRequest_;
    SecurityDefinitionRequestMsg securityDefinitionRequest_;
    CancelRequestMsg cancelRequest_;
    CancelReplaceRequestMsg replaceRequest_;
    NewOrderCrossRequestMsg newOrderCrossRequest_;
    OrderMassCancelRequestMsg orderMassCancelRequest_;
    QuoteRequestMsg quoteRequest_;
    QuoteCancelRequestMsg quoteCancelRequest_;
    MassQuoteRequestMsg massQuoteRequest_;
 
    static void checkConnected(const SessionPtr& sn, const char* kind);
 
    template<class Message>
    static void send(const SessionPtr& sn, Message&& msg);
 
    OptionalRef<Order> findByOrderId(OrderId id);
 
    template <typename MsgType>
    static void setCommonMessageFields(Order& order, MsgType&& msg);
 
    OrderPtr newOrder(const Order* base = nullptr);
    CrossOrderPtr newOrderCross();
 
    #define ONIXS_ICE_TRADING_CLIENT_MSG_CALLBACK(Msg) \
        void on##Msg(const Msg msg, Session* sn) override {CUI::Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);}

    void onError(SessionErrorReason::Enum reason, const std::string & description, Session * sn, Messaging::SbeMessage) override;
    void onWarning(SessionWarningReason::Enum reason, const std::string & description, Session * sn, Messaging::SbeMessage) override;
    void onStateChange(SessionStateId::Enum newState, SessionStateId::Enum prevState, Session * sn) override;
    void onMessageSending(char*, size_t, Session*) override;
    void onIPReport(const Messaging::IPReport msg, Session* sn) override;
    void onSecurityDefinitionReport(const Messaging::SecurityDefinitionReport msg, Session* sn) override;
    void onSecurityDefinitionReport_Strategy(const Messaging::SecurityDefinitionReport_Strategy msg, Session* sn) override;
 
    void onExecutionReport_New(const Messaging::ExecutionReport_New msg, Session* sn) override;
    void onExecutionReport_Reject(const Messaging::ExecutionReport_Reject msg, Session* sn) override;
    void onExecutionReport_Cancel(const Messaging::ExecutionReport_Cancel msg, Session* sn) override;
    void onExecutionReport_Modify(const Messaging::ExecutionReport_Modify msg, Session* sn) override;
    void onExecutionReport_Trade(const Messaging::ExecutionReport_Trade msg, Session* sn) override;
    void onExecutionReport_Snapshot(const Messaging::ExecutionReport_Snapshot msg, Session* sn) override;
    void onNewOrderCrossReport(const Messaging::NewOrderCrossReport msg, Session* sn) override;
    ONIXS_ICE_TRADING_CLIENT_MSG_CALLBACK(LogonReport);
    ONIXS_ICE_TRADING_CLIENT_MSG_CALLBACK(LogoutReport);
    ONIXS_ICE_TRADING_CLIENT_MSG_CALLBACK(News);
    ONIXS_ICE_TRADING_CLIENT_MSG_CALLBACK(SecurityDefinitionReport_Product);
    ONIXS_ICE_TRADING_CLIENT_MSG_CALLBACK(TraderLogonReport);
    ONIXS_ICE_TRADING_CLIENT_MSG_CALLBACK(TraderLogoutReport);
    ONIXS_ICE_TRADING_CLIENT_MSG_CALLBACK(QuoteReport);
    ONIXS_ICE_TRADING_CLIENT_MSG_CALLBACK(OrderMassCancelReport);
    ONIXS_ICE_TRADING_CLIENT_MSG_CALLBACK(MassQuoteReport);
    ONIXS_ICE_TRADING_CLIENT_MSG_CALLBACK(SequenceReset);
    ONIXS_ICE_TRADING_CLIENT_MSG_CALLBACK(ResendReport);
    ONIXS_ICE_TRADING_CLIENT_MSG_CALLBACK(Error);
    ONIXS_ICE_TRADING_CLIENT_MSG_CALLBACK(SecurityDefinitionReject);
};
 
template<class Message>
void TradingClient::send(const SessionPtr& sn, Message&& msg)
{
    sn->send(std::forward<Message>(msg));
}
 
template <typename MsgType>
void TradingClient::setCommonMessageFields(Order& order, MsgType&& msg)
{
    order.transactTime_ = getTransactTime(msg);
    setLeavesQty(order, msg);
}
 
}