Trading Client Sample

A sample CLI trading client demonstrating order lifecycle (submit/replace/cancel), including message processing and event dispatch.

Source code

• Main.cpp
• TradingClient.h
• TradingClient.cpp
• Order.h
• Order.cpp
• Book.h
• Utils.h
• CUI.h
• Settings.h

---

Main.cpp

/*
 * 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.
 */
 
#include <Common/Helpers.h>
#include <Common/Settings.h>
#include <Common/Signal.h>
 
#include "Settings.h"
#include "TradingClient.h"
 
using namespace Samples;
 
int main(int argc, char * argv[])
{
    try
    {
        // `--help` to show options.
        const AppConfiguration<SettingsConfiguration> cfg{"TradingClient", argc, argv};
 
        const Settings settings{cfg.settingsFile()};
        TradingClient client{settings};
 
        const auto connectBus = [&client]{ client.connectBus(); };
        const auto requestBgwCredentials = [&client]{ client.requestBgwCredentials(); };
        const auto connectBgw = [&client]{ client.connectBgw(); };
        const auto traderLogon = [&client]{ client.traderLogon(); };
 
        CUI::Menu menu{
            {"Print this message", "Printing available options", [&menu]{ menu.outputItems(); }},
 
            {"Connect BUS session", "Connecting a BUS session",            connectBus},
            {"Request BGW credentials", "Requesting BGW credentials",      requestBgwCredentials},
            {"Request instruments", "Requesting SecurityDefinition data",  [&client]{ client.requestInstruments(); }},
            {"List known instruments", "Listing instruments",              [&client]{ client.listInstruments(); }},
            {"Show instrument by provided symbol", "Looking up the instrument",[&client]{ client.lookupInstruments(); }},
 
            {"Connect BGW session", "Connecting a BGW session",            connectBgw},
            {"Trader log on",       "Logging trader on",                   traderLogon},
            {"Trader log out",      "Logging trader out",                  [&client]{ client.traderLogout(); }},
 
            {"Send order",          "Sending order",                       [&client]{ client.sendOrder(); }},
            {"Send cross order",    "Sending cross order",                 [&client]{ client.sendOrderCross(); }},
            {"Cancel order",        "Cancelling order",                    [&client]{ client.cancelOrder(); }},
            {"Replace order",       "Replacing order",                     [&client]{ client.replaceOrder(); }},
            {"Mass cancel",         "Cancelling matching working orders",  [&client]{ client.sendMassCancel(); }},
 
            {"Show orders",         "Viewing orders and status",           [&client]{ client.showOrders(); }},
            {"Show active orders",  "Viewing active orders",               [&client]{ client.showActiveOrders(); }},
 
 
            {"Send RFQ",            "Sending quote",                       [&client]{ client.sendQuote(); }},
            {"Send mass quote",     "Sending mass quote",                  [&client]{ client.sendMassQuote(); }},
            {"Cancel quote",        "Sending quote cancel",                [&client]{ client.sendQuoteCancelRequest(); }},
 
            {"Create strategy",     "Creating strategy",                   [&client]{ client.createStrategy(); }},
            {"Create flex",         "Creating flexible instrument",        [&client]{ client.createFlex(); }},
 
 
            {"*Get ready BGW session (shortcut)", "Preparing BGW session", {connectBus, requestBgwCredentials, connectBgw, traderLogon}},
            {"Exit",                "Closing connections and exiting",     [&menu]{ menu.stopRequest(); }}
        };
 
        menu.processRequests();
    }
    catch (const std::exception& ex)
    {
        std::cerr << std::endl << "Error: " << ex.what() << "." << std::endl;
        return 1;
    }
 
    return 0;
}

---

TradingClient.h

/*
* 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);
}
 
}

---

TradingClient.cpp

/*
* 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.
*/
#include <OnixS/ICE/BOE/IceBoe.h>
 
#include <Settings/Defaults.h>
#include <Common/Tools.h>
#include <Common/Helpers.h>
#include "Utils.h"
 
#include "TradingClient.h"
 
namespace Samples {
 
using namespace ONIXS_ICEBOE_NAMESPACE;
using namespace ONIXS_ICEBOE_MESSAGING_NAMESPACE;
using namespace CUI;
 
namespace {
 
void checkSettingSanity(const Settings& settings)
{
    const auto traderId = settings.get("TraderId");
    const auto traderPwd = settings.get("TraderPwd");
    const auto clientId = settings.get<Int32>("ClientId");
    const auto userId = settings.get("UserId");
    const auto userPwd = settings.get("Password");
    const auto host = settings.get("Host");
    const auto port = settings.get<Port>("Port");
    const auto onBehalfOfSubId = settings.get("OnBehalfOfSubId");
    const auto onBehalfOfLocationId = settings.get("OnBehalfOfLocationId");
    const auto onBehalfOfCompId = settings.get("OnBehalfOfCompId");
    const auto clearingFirm = settings.get<Int32>("ClearingFirm");
    const auto clearingAccount = settings.get("ClearingAccount");
    const auto mifidId = settings.get<Int64>("MifidId");
    const auto keepAliveInterval = settings.get<UInt16>("KeepAliveInterval");
    const auto investmentDecision = settings.get<Int64>("InvestmentDecision");
    const auto executionDecision = settings.get<Int64>("ExecutionDecision");
 
    ignoreUnusedVariableWarning(
        traderId
        ,traderPwd
        ,clientId
        ,userId
        ,userPwd
        ,host
        ,port
        ,onBehalfOfSubId
        ,onBehalfOfLocationId
        ,onBehalfOfCompId
        ,clearingFirm
        ,clearingAccount
        ,mifidId
        ,keepAliveInterval
        ,investmentDecision
        ,executionDecision
    );
}
 
SessionSettings fillSessionSettings(const Settings& settings)
{
    checkSettingSanity(settings);
 
    SessionSettings sessionSettings;
 
    sessionSettings
        .licenseStore("../../license")
        .userId(settings.get("UserId"))
        .clientId(settings.get<Int32>("ClientId"))
        .rawData(settings.get("Password"))
        .reconnectAttempts(100)
        .reconnectInterval(1)
        .keepAliveInterval(settings.get<UInt16>("KeepAliveInterval"))
        .useTLS(settings.get<Port>("Port") == Default::TlsPort)
        ;
 
    return sessionSettings;
}
 
auto initSecurityDefinitionRequest(const Settings&)
{
    SecurityDefinitionRequestMsg request;
    return request;
}
 
auto initNewOrder(const Settings& settings)
{
    NewOrderRequestMsg request;
 
    request->
        originatorUserId(settings.get("TraderId"))
        .onBehalfOfSubId(settings.get("OnBehalfOfSubId"))
        .onBehalfOfLocationId(settings.get("OnBehalfOfLocationId"))
        .onBehalfOfCompId(settings.get("OnBehalfOfCompId"))
        .clearingFirm(settings.get<Int32>("ClearingFirm"))
        .clearingAccount(settings.get("ClearingAccount"))
        .mifidId(settings.get<Int64NULL>("MifidId"))
        .manualOrderIndicator(BooleanEnum::True)
        .custOrderHandlingInst(CustOrderHandlingInstEnum::Y)
        .memo("NewOrderRequest")
        .selfMatchPreventionInstruction(SelfMatchPreventionInstructionEnum::CancelTakingOrder);
 
    if(settings.isSet("SelfMatchPreventionId"))
        request->selfMatchPreventionId(settings.get<Int64>("SelfMatchPreventionId"));
 
    return request;
}
 
auto initOrderCancelRequest(const Settings& settings)
{
    CancelRequestMsg request;
 
    request->originatorUserId(settings.get("TraderId"));
 
    return request;
}
 
auto initOrderReplaceRequest(const Settings& settings)
{
    CancelReplaceRequestMsg request;
 
    request->
         originatorUserId(settings.get("TraderId"))
        .onBehalfOfSubId(settings.get("OnBehalfOfSubId"))
        .onBehalfOfLocationId(settings.get("OnBehalfOfLocationId"))
        .onBehalfOfCompId(settings.get("OnBehalfOfCompId"))
        .clearingFirm(settings.get<Int32>("ClearingFirm"))
        .clearingAccount(settings.get("ClearingAccount"))
        .mifidId(settings.get<Int64NULL>("MifidId"))
        .manualOrderIndicator(BooleanEnum::True)
        .memo("CancelReplaceRequest")
        .selfMatchPreventionInstruction(SelfMatchPreventionInstructionEnum::CancelTakingOrder);
 
    if(settings.isSet("SelfMatchPreventionId"))
        request->selfMatchPreventionId(settings.get<Int64>("SelfMatchPreventionId"));
 
    return request;
}
 
auto initNewOrderCrossRequest(const Settings& settings)
{
    NewOrderCrossRequestMsg request;
 
    const auto onBehalfOfSubId = settings.get("OnBehalfOfSubId");
    const auto onBehalfOfLocationId = settings.get("OnBehalfOfLocationId");
    const auto onBehalfOfCompId = settings.get("OnBehalfOfCompId");
    const auto clearingFirm = settings.get<Int32>("ClearingFirm");
    const auto clearingAccount = settings.get("ClearingAccount");
    const auto mifidId = settings.get<Int64NULL>("MifidId");
 
    request->originatorUserId(settings.get("TraderId"));
    request->crossType(CrossTypeEnum::IOC);
 
    auto sides = request->sides(2);
 
    sides[0]
        .onBehalfOfSubId(onBehalfOfSubId)
        .onBehalfOfLocationId(onBehalfOfLocationId)
        .onBehalfOfCompId(onBehalfOfCompId)
        .clearingFirm(clearingFirm)
        .clearingAccount(clearingAccount)
        .mifidId(mifidId)
        .manualOrderIndicator(BooleanEnum::True)
        .memo("NewOrderCrossRequest[0]")
        .custOrderHandlingInst(CustOrderHandlingInstEnum::Y)
        .selfMatchPreventionInstruction(SelfMatchPreventionInstructionEnum::CancelTakingOrder);
 
    sides[1]
        .onBehalfOfSubId(onBehalfOfSubId)
        .onBehalfOfLocationId(onBehalfOfLocationId)
        .onBehalfOfCompId(onBehalfOfCompId)
        .clearingFirm(clearingFirm)
        .clearingAccount(clearingAccount)
        .mifidId(mifidId)
        .manualOrderIndicator(BooleanEnum::True)
        .memo("NewOrderCrossRequest[1]")
        .custOrderHandlingInst(CustOrderHandlingInstEnum::Y)
        .selfMatchPreventionInstruction(SelfMatchPreventionInstructionEnum::CancelTakingOrder);
 
    if(settings.isSet("SelfMatchPreventionId"))
    {
        const auto id = settings.get<Int64>("SelfMatchPreventionId");
        sides[0].selfMatchPreventionId(id);
        sides[1].selfMatchPreventionId(id);
    }
 
    return request;
}
 
auto initOrderMassCancelRequest(const Settings& settings)
{
    OrderMassCancelRequestMsg request;
 
    request->originatorUserId(settings.get("TraderId"));
    request->massCancelRequestType(MassCancelRequestTypeEnum::CancelAllForTrader);
 
    return request;
}
 
auto initQuoteRequest(const Settings& settings)
{
    QuoteRequestMsg request;
 
    request->
         originatorUserId(settings.get("TraderId"))
        .onBehalfOfSubId(settings.get("OnBehalfOfSubId"))
        .onBehalfOfLocationId(settings.get("OnBehalfOfLocationId"))
        .onBehalfOfCompId(settings.get("OnBehalfOfCompId"))
        .clearingFirm(settings.get<Int32>("ClearingFirm"))
        .clearingAccount(settings.get("ClearingAccount"));
 
    return request;
}
 
auto initQuoteCancelRequest(const Settings& settings)
{
    QuoteCancelRequestMsg request;
 
    request->originatorUserId(settings.get("TraderId"));
    request->quoteCancelType(QuoteCancelTypeEnum::CancelByUnderlyingMarket);
    request->quoteEntries(1);
 
    return request;
}
 
auto initMassQuoteRequest(const Settings& settings)
{
    MassQuoteRequestMsg request;
 
    request->
        mifidId(settings.get<Int64NULL>("MifidId"))
        .selfMatchPreventionInstruction(SelfMatchPreventionInstructionEnum::CancelTakingOrder)
        .riskProtectionReset(BooleanEnum::True)
        .directElectronicAccess(BooleanEnum::True)
        .originatorUserId(settings.get("TraderId"))
    ;
 
    if(settings.isSet("SelfMatchPreventionId"))
        request->selfMatchPreventionId(settings.get<Int64>("SelfMatchPreventionId"));
 
    request->quoteSets(MassQuoteRequestMaxEntriesCount);
    return request;
}
 
 
auto queryString(const char* name, const std::string& defaultValue)
{
    Screen::out("Enter ", name, " (default=", defaultValue, "): ");
    return Screen::getInput(defaultValue);
}
 
auto queryTimestamp(const char* name, Timestamp defaultValue)
{
    Screen::out("Enter ", name, " (default=", toStr(defaultValue, TimestampFormat::YYYYMMDD), "): ");
    const auto userInput = Screen::getInput<std::string>();
 
    if(userInput.empty())
        return defaultValue;
 
    return Timestamp::fromStr(userInput, TimestampFormat::YYYYMMDD);
}
 
template <typename OptionalType>
auto queryOptionalTimestamp(const char* name, OptionalType defaultValue = {})
{
    Screen::out("Enter ", name, ", optional, (default=", defaultValue ? toStr(*defaultValue, TimestampFormat::YYYYMMDD) : toStr(nullOpt), "): ");
    const auto userInput = Screen::getInput<std::string>();
 
    if(userInput.empty())
        return defaultValue;
 
    if(userInput == toStr(nullOpt))
        return OptionalType{};
 
    return OptionalType{Timestamp::fromStr(userInput, TimestampFormat::YYYYMMDD)};
}
 
template <typename T>
auto queryNumeric(const char* name, T defaultValue, typename std::enable_if<std::is_integral<T>::value, void*>::type = nullptr)
{
    Screen::out("Enter ", name, " (default=", toStr(defaultValue), "): ");
    return Screen::getInput<T>(defaultValue);
}
 
template <typename OptionalType>
auto queryOptionalNumeric(const char* name, typename std::enable_if<isOptional<OptionalType>::value && std::is_integral<typename OptionalType::HeldType>::value, void*>::type = nullptr)
{
    Screen::out("Enter ", name, ", optional, (default=", toStr(nullOpt), "): ");
 
    const auto userInput = Screen::getInput(toStr(nullOpt));
 
    if(userInput.empty() || userInput == toStr(nullOpt))
        return OptionalType{};
 
    return OptionalType{parseUserInput<typename OptionalType::HeldType>(userInput)};
}
 
auto queryDecimal(const char* name, Decimal9 defaultValue)
{
    Screen::out("Enter ", name, " (default=", toStr(Decimal{defaultValue, -9}), "): ");
    const auto userInput = Screen::getInput<std::string>();
 
    if(userInput.empty())
        return defaultValue;
 
    return toPriceMantissa(parseUserInput<double>(userInput));
}
 
template <typename OptionalType>
auto queryOptionalDecimal(const char* name, OptionalType defaultValue = {}, typename std::enable_if<isOptional<OptionalType>::value, void*>::type=nullptr)
{
    Screen::out("Enter ", name, ", optional, (default=", toStr(defaultValue), "): ");
 
    const auto userInput = Screen::getInput(toStr(defaultValue));
 
    if(userInput.empty())
        return defaultValue;
 
    if(userInput == toStr(nullOpt))
        return OptionalType{};
 
    return OptionalType{toPriceMantissa(parseUserInput<double>(userInput))};
}
 
template<typename Type, size_t Size>
auto queryEnum(const char* name, const Type (&allowedValues)[Size], Type defaultValue, typename std::enable_if<isScopedEnum<Type>::value, void*>::type=nullptr)
{
    const std::set<Type> val{std::begin(allowedValues), std::end(allowedValues)};
    Screen::out("Enter ", name, " [", join(val.begin(), val.end(), ','), "] (default=", toStr(defaultValue), "):");
 
    const auto userInput = Screen::getInput<std::string>();
 
    if(userInput.empty())
        return defaultValue;
 
    const auto value = parseUserInput<Type>(userInput);
 
    if(val.find(value) == val.end())
        throw std::invalid_argument("Invalid user input: '" + toStr(value) + "'");
 
    return value;
}
 
template<typename OptionalType, size_t Size>
auto queryOptionalEnum(const char* name, const typename OptionalType::HeldType (&allowedValues)[Size], OptionalType defaultValue = {}, typename std::enable_if<isOptional<OptionalType>::value && isScopedEnum<typename OptionalType::HeldType>::value, void*>::type=nullptr)
{
    const std::set<typename OptionalType::HeldType> val{std::begin(allowedValues), std::end(allowedValues)};
    Screen::out("Enter ", name, " [", join(val.begin(), val.end(), ','), "], optional, (default=", toStr(nullOpt), "):");
 
    const auto userInput = Screen::getInput<std::string>();
 
    if(userInput.empty())
        return defaultValue;
 
    if(userInput == toStr(nullOpt))
        return OptionalType{};
 
    const auto value = parseUserInput<typename OptionalType::HeldType>(userInput);
 
    return OptionalType{value};
}
 
template<size_t Size>
auto querySide(const SideEnum (&allowedValues)[Size], SideEnum defaultValue = Default::Side)
{
    return queryEnum("Side", allowedValues, defaultValue);
}
 
template<typename OptionalType, size_t Size>
auto querySideOptional(const SideEnum (&allowedValues)[Size])
{
    return queryOptionalEnum<OptionalType>("Side", allowedValues);
}
 
template<size_t Size>
auto queryOrderType(const OrderTypeEnum (&allowedValues)[Size], OrderTypeEnum defaultValue = OrderTypeEnum::Limit)
{
    return queryEnum("OrderType", allowedValues, defaultValue);
}
 
template<typename OptionalType, size_t Size>
auto queryOrderTypeOptional(const typename OptionalType::HeldType (&allowedValues)[Size])
{
     return queryOptionalEnum<OptionalType, Size>("OrderType", allowedValues);
}
 
template<size_t Size>
auto queryTimeInForce(const TimeInForceEnum (&allowedValues)[Size], TimeInForceEnum defaultValue = TimeInForceEnum::Day)
{
    return queryEnum("TimeInForce", allowedValues, defaultValue);
}
 
template<typename OptionalType, size_t Size>
auto queryTimeInForceOptional(const TimeInForceEnum (&allowedValues)[Size])
{
    return queryOptionalEnum<OptionalType, Size>("TimeInForce", allowedValues);
}
 
template<size_t Size>
auto querySecurityRequestType(const SecurityRequestTypeEnum (&allowedValues)[Size], SecurityRequestTypeEnum defaultValue = SecurityRequestTypeEnum::RequestListofOptions)
{
    return queryEnum("SecurityRequestType", allowedValues, defaultValue);
}
 
template<typename OptionalType, size_t Size>
auto queryPriceTypeOptional(const typename OptionalType::HeldType (&allowedValues)[Size])
{
    return queryOptionalEnum<OptionalType, Size>("PriceType", allowedValues);
}
 
template<typename OptionalType, size_t Size>
auto queryBenchmarkPriceTypeOptional(const typename OptionalType::HeldType (&allowedValues)[Size])
{
    return queryOptionalEnum<OptionalType, Size>("BenchmarkPriceType", allowedValues);
}
 
template<typename OptionalType, size_t Size>
auto queryExecInstOptional(const typename OptionalType::HeldType (&allowedValues)[Size], OptionalType defaultValue)
{
    return queryOptionalEnum<OptionalType, Size>("ExecInst", allowedValues, defaultValue);
}
 
template<typename OptionalType, size_t Size>
auto queryBooleanOptional(const char* name, const BooleanEnum (&allowedValues)[Size])
{
    return queryOptionalEnum<OptionalType>(name, allowedValues);
}
 
template<size_t Size>
auto queryCustOrderHandlingInst(const CustOrderHandlingInstEnum (&allowedValues)[Size], CustOrderHandlingInstEnum defaultValue = CustOrderHandlingInstEnum::Y)
{
    return queryEnum("CustOrderHandlingInst", allowedValues, defaultValue);
}
 
struct QuoteIdGenerator
{
    static Int64 id()
    {
        return static_cast<Int64>(UtcWatch::now().sinceEpoch() / TimeTraits::nanosecondsPerSecond());
    }
};
 
}
 
void TradingClient::checkConnected(const SessionPtr& sn, const char* kind)
{
    const bool connected = sn && sn->state() == SessionStateId::Established;
 
    if(!connected)
        throw std::runtime_error("A " + std::string(kind) + " session must be in the [Established] state");
}
 
TradingClient::TradingClient(const Settings& settings)
    : settings_(settings)
    , sessionSettings_(fillSessionSettings(settings_))
    , newOrderRequest_(initNewOrder(settings))
    , securityDefinitionRequest_(initSecurityDefinitionRequest(settings))
    , cancelRequest_(initOrderCancelRequest(settings))
    , replaceRequest_(initOrderReplaceRequest(settings))
    , newOrderCrossRequest_(initNewOrderCrossRequest(settings))
    , orderMassCancelRequest_(initOrderMassCancelRequest(settings))
    , quoteRequest_(initQuoteRequest(settings))
    , quoteCancelRequest_(initQuoteCancelRequest(settings))
    , massQuoteRequest_(initMassQuoteRequest(settings))
{
}
 
OptionalRef<Order> TradingClient::findByOrderId(OrderId orderId)
{
    auto ord = orderBook_.find(orderId);
 
    if (!ord)
         CUI::Screen::warning("No order with id=", orderId, " is found");
 
    return ord;
}
 
void TradingClient::connectBus()
{
    auto settings = sessionSettings_;
 
    if(!busSession_)
        busSession_.reset(new Session(SessionType::BUS, settings, this));
 
    busSession_->connect(settings_.get("Host"), settings_.get<Port>("Port"));
}
 
void TradingClient::requestBgwCredentials()
{
    checkConnected(busSession_, "BUS");
 
    const auto userId = settings_.get("UserId");
 
    MessageHolder<IPRequest, getMaxMessageSize<IPRequest>(1)> request;
    request->clientId(sessionSettings_.clientId());
    request->users(1)[0].userId(userId);
 
    bgwCredentials_ = {};
    TradingClient::send(busSession_, request);
}
 
void TradingClient::requestInstruments()
{
    checkConnected(busSession_, "BUS");
 
    const auto marketTypeId = queryNumeric("MarketTypeId", Default::MarketTypeId);
    const auto requestType = querySecurityRequestType(
            {SecurityRequestTypeEnum::RequestListofOptions,
             SecurityRequestTypeEnum::RequestListofStrategies,
             SecurityRequestTypeEnum::RequestListofFutures,
             SecurityRequestTypeEnum::RequestListOfProducts
            });
 
    MessageHolder<SecurityDefinitionRequest> request;
    request->marketTypeId(marketTypeId);
    request->securityReqId(static_cast<Int32>(IdGenerator::newId() & 0xFFFFFFFFull));
    request->securityRequestType(requestType);
 
    instruments_.clear();
    send(busSession_, request);
}
 
void TradingClient::listInstruments()
{
    std::vector<Messaging::SbeMessage> messages;
 
    for (auto element : instruments_)
        messages.push_back(Messaging::SbeMessage{element->data(), static_cast<Messaging::SbeMessage::EncodedLength>(element->size())});
 
    std::reverse(messages.begin(), messages.end());
 
    ListViewer::outputItems(messages, [](auto msg)
    {
        std::string res;
 
        if(!ONIXS_ICEBOE_MESSAGING_NAMESPACE::processTypified(msg, [&](const auto msg) { toStr(res, msg); }))
            res = "[]";
 
        return res;
    }, 10);
}
 
void TradingClient::lookupInstruments()
{
    const auto symbol = queryNumeric("Symbol", Default::Symbol);
 
    std::vector<Messaging::SecurityDefinitionReport> messages;
 
    for (auto element : instruments_)
    {
        const Messaging::SecurityDefinitionReport msg{element->data(), static_cast<Messaging::SbeMessage::EncodedLength>(element->size())};
 
        if(msg.symbol() == symbol)
            messages.push_back(msg);
    }
 
    ListViewer::outputItems(messages, [](auto msg){return toStr(msg);}, 10);
}
 
void TradingClient::connectBgw()
{
    if(!bgwCredentials_)
        throw std::runtime_error("BGW credentials must be obtained first");
 
    auto settings = sessionSettings_;
 
    if(!bgwSession_)
        bgwSession_.reset(new Session(SessionType::BGW, settings, this));
 
    bgwSession_->connect(bgwCredentials_.host(), bgwCredentials_.port(), bgwCredentials_.ipSessionToken());
}
 
void TradingClient::traderLogon()
{
    checkConnected(bgwSession_, "BGW");
 
    MessageHolder<TraderLogonRequest> request;
    request->originatorUserId(settings_.get("TraderId"));
    request->rawData(settings_.get("TraderPwd"));
    request->directElectronicAccess(BooleanEnum::True);
    request->tradingCapacity(TradingCapacityEnum::DEAL);
    request->liquidityProvision(BooleanEnum::True);
    request->commodityDerivIndicator(BooleanEnum::False);
    request->investmentDecision(settings_.get<Int64>("InvestmentDecision"));
    request->executionDecision(settings_.get<Int64>("ExecutionDecision"));
 
    TradingClient::send(bgwSession_, request);
}
 
void TradingClient::traderLogout()
{
    checkConnected(bgwSession_, "BGW");
 
    MessageHolder<TraderLogoutRequest> request;
    request->originatorUserId(settings_.get("TraderId"));
 
    TradingClient::send(bgwSession_, request);
}
 
void TradingClient::sendOrder()
{
    checkConnected(bgwSession_, "BGW");
 
    const auto order = orderBook_.store(newOrder());
    Screen::info(order.toString());
 
    newOrderRequest_->price(order.price_.raw())
        .orderQty(order.orderQty_)
        .symbol(order.securityId_)
        .clOrdId(order.cIOrdId_)
        .stopPx(order.stopPx_.raw())
        .ordType(order.ordType_)
        .timeInForce(order.timeInForce_)
        .side(order.side_)
        .maxShow(order.maxShow_.raw())
        .execInst(order.execInst_.raw())
        ;
 
    if (order.timeInForce_ == TimeInForceEnum::GTD && order.expireDate_)
        newOrderRequest_->expireDate(*order.expireDate_);
    else
        newOrderRequest_->expireDate(nullOpt);
 
    const auto custOrderHandlingInst =
        queryCustOrderHandlingInst({
            CustOrderHandlingInstEnum::C
            ,CustOrderHandlingInstEnum::D
            ,CustOrderHandlingInstEnum::G
            ,CustOrderHandlingInstEnum::H
            ,CustOrderHandlingInstEnum::W
            ,CustOrderHandlingInstEnum::Y
        });
 
    newOrderRequest_->custOrderHandlingInst(custOrderHandlingInst);
 
    const auto selfMatchPreventionInstruction =
        queryOptionalEnum<decltype(std::declval<const NewOrderRequest&>().selfMatchPreventionInstruction())>(
        "SelfMatchPreventionInstruction",
        {
            SelfMatchPreventionInstructionEnum::CancelRestingOrder
            ,SelfMatchPreventionInstructionEnum::CancelTakingOrder
            ,SelfMatchPreventionInstructionEnum::CancelBothOrders
        });
 
    newOrderRequest_->selfMatchPreventionInstruction(selfMatchPreventionInstruction.raw());
 
    TradingClient::send(bgwSession_, newOrderRequest_);
}
 
void TradingClient::sendOrderCross()
{
    checkConnected(bgwSession_, "BGW");
 
    const auto transactDetails = queryString("TransactDetails", "***");
 
    const auto priceType =
        queryPriceTypeOptional<decltype(std::declval<const NewOrderCrossRequest&>().priceType())>({
            PriceTypeEnum::PerContract,
            PriceTypeEnum::FixedCabinetTradePrice,
            PriceTypeEnum::FixedRate,
            PriceTypeEnum::NPV,
            PriceTypeEnum::RateDifferential,
            PriceTypeEnum::NPVDifferential});
 
    const auto benchmarkPriceType =
            queryBenchmarkPriceTypeOptional<decltype(std::declval<const NewOrderCrossRequest&>().benchMarkPriceType())>({
                BenchmarkPriceTypeEnum::FixedAmount});
 
    const auto bmPrice =
            queryOptionalDecimal<decltype(std::declval<const NewOrderCrossRequest&>().benchmarkPrice())>("BenchmarkPrice");
 
    const auto crossType = queryEnum("CrossType", {CrossTypeEnum::AON, CrossTypeEnum::IOC}, CrossTypeEnum::AON);
 
    const auto custOrderHandlingInst =
            queryCustOrderHandlingInst({
                CustOrderHandlingInstEnum::C
                ,CustOrderHandlingInstEnum::D
                ,CustOrderHandlingInstEnum::G
                ,CustOrderHandlingInstEnum::H
                ,CustOrderHandlingInstEnum::W
                ,CustOrderHandlingInstEnum::Y
            });
 
    newOrderCrossRequest_->priceType(priceType.raw());
    newOrderCrossRequest_->benchMarkPriceType(benchmarkPriceType.raw());
    newOrderCrossRequest_->benchmarkPrice(bmPrice.raw());
    newOrderCrossRequest_->transactDetails(toStrRef(transactDetails));
    newOrderCrossRequest_->crossType(crossType);
 
    auto crossOrder = orderBook_.store(newOrderCross());
 
    Screen::info(crossOrder.toString());
 
    const auto& buySideOrder = *crossOrder.buySideOrder_;
    const auto& sellSideOrder = *crossOrder.sellSideOrder_;
 
    auto sides = newOrderCrossRequest_->sides();
    assert(sides.size() == 2);
 
    newOrderCrossRequest_->crossId(crossOrder.id());
 
    newOrderCrossRequest_->price(buySideOrder.price_.raw())
        .orderQty(buySideOrder.orderQty_)
        .symbol(buySideOrder.securityId_)
        .ordType(buySideOrder.ordType_)
        .timeInForce(buySideOrder.timeInForce_);
 
    sides[0].side(buySideOrder.side_);
    sides[0].clOrdId(buySideOrder.cIOrdId_);
    sides[0].custOrderHandlingInst(custOrderHandlingInst);
 
    sides[1].side(sellSideOrder.side_);
    sides[1].clOrdId(sellSideOrder.cIOrdId_);
    sides[1].custOrderHandlingInst(custOrderHandlingInst);
 
    newOrderCrossRequest_->transactTime(UtcWatch::now());
 
    TradingClient::send(bgwSession_, newOrderCrossRequest_);
}
 
void TradingClient::sendMassCancel()
{
    checkConnected(bgwSession_, "BGW");
 
    orderMassCancelRequest_->clOrdId(IdGenerator::newId());
 
    const auto requestType = queryEnum(
        "RequestType", {MassCancelRequestTypeEnum::CancelAllForTrader, MassCancelRequestTypeEnum::CancelForTradingSession}, MassCancelRequestTypeEnum::CancelAllForTrader);
 
    const auto ordType = queryOrderTypeOptional<decltype(std::declval<const OrderMassCancelRequest&>().ordType())>(
        {OrderTypeEnum::Limit});
 
    const auto side = querySideOptional<decltype(std::declval<const OrderMassCancelRequest&>().side())>(
        {SideEnum::Buy, SideEnum::Sell});
 
    const auto symbol = queryOptionalNumeric<decltype(std::declval<const OrderMassCancelRequest&>().symbol())>("Symbol");
 
    const auto marketTypeId = queryOptionalNumeric<decltype(std::declval<const OrderMassCancelRequest&>().marketTypeId())>("MarketTypeId");
 
    const auto price = queryOptionalDecimal<decltype(std::declval<const OrderMassCancelRequest&>().price())>("Price");
 
    const auto timeInForce = queryTimeInForceOptional<decltype(std::declval<const OrderMassCancelRequest&>().timeInForce())>({TimeInForceEnum::Day});
 
    const auto onBehalfOfSubId = queryString("OnBehalfOfSubId", "");
 
    orderMassCancelRequest_->massCancelRequestType(requestType);
    orderMassCancelRequest_->ordType(ordType.raw());
    orderMassCancelRequest_->side(side.raw());
    orderMassCancelRequest_->symbol(symbol.raw());
    orderMassCancelRequest_->marketTypeId(marketTypeId.raw());
    orderMassCancelRequest_->price(price.raw());
    orderMassCancelRequest_->timeInForce(timeInForce.raw());
    orderMassCancelRequest_->onBehalfOfSubId(toStrRef(onBehalfOfSubId));
 
    TradingClient::send(bgwSession_, orderMassCancelRequest_);
}
 
void TradingClient::sendQuote()
{
    checkConnected(bgwSession_, "BGW");
 
    const auto qti = queryDecimal("Quantity", Default::QuantityMantissa);
    const auto side = querySide({SideEnum::Buy, SideEnum::Sell});
    const auto symbol = queryNumeric("Symbol", Default::Symbol);
 
    quoteRequest_
        ->rfqReqId(IdGenerator::newId())
        .orderQty(qti)
        .side(side)
        .symbol(symbol);
 
    TradingClient::send(bgwSession_, quoteRequest_);
}
 
Int32 TradingClient::getQuoteSetId(Int32 underlyingSymbol)
{
    for(auto&& pair : quoteSetId_)
    {
        if(pair.second == underlyingSymbol)
            return pair.first;
    }
 
    quoteSetId_.emplace_back(static_cast<Int32>(quoteSetId_.size() + 1), underlyingSymbol);
    return quoteSetId_.back().first;
}
 
void TradingClient::sendMassQuote()
{
    checkConnected(bgwSession_, "BGW");
 
    massQuoteRequest_->quoteId(QuoteIdGenerator::id());
 
    const auto riskProtectionReset =
    queryBooleanOptional<decltype(std::declval<const MassQuoteRequest&>().riskProtectionReset())>(
            "RiskProtectionReset", {BooleanEnum::False, BooleanEnum::True});
 
    massQuoteRequest_->riskProtectionReset(riskProtectionReset.raw());
 
    const auto quotes = massQuoteRequest_->quoteSets();
 
    for(auto&& quote : quotes)
    {
        const auto underlyingSymbol = queryNumeric("Underlying Symbol", Default::UnderlyingSymbol);
 
        quote
            .quoteEntryId(static_cast<Int32>(IdGenerator::newId()))
            .underlyingSymbol(underlyingSymbol)
            .quoteSetId(getQuoteSetId(underlyingSymbol))
            .symbol(queryNumeric("Symbol", Default::Symbol))
            .bidPx(queryDecimal("Bid Price", Default::PriceMantissa))
            .bidSz(queryDecimal("Bid Size", Default::QuantityMantissa))
            .offerPx(queryDecimal("Offer Price", Default::PriceMantissa))
            .offerSz(queryDecimal("Offer Size", Default::QuantityMantissa))
        ;
    }
 
    TradingClient::send(bgwSession_, massQuoteRequest_);
}
 
void TradingClient::sendQuoteCancelRequest()
{
    checkConnected(bgwSession_, "BGW");
 
    quoteCancelRequest_->quoteId(QuoteIdGenerator::id());
    assert(quoteCancelRequest_->quoteEntries().size() == 1);
 
    const auto quoteCancelType = queryEnum("QuoteCancelType",
       { QuoteCancelTypeEnum::CancelAll, QuoteCancelTypeEnum::CancelByProductID, QuoteCancelTypeEnum::CancelByUnderlyingMarket},
       QuoteCancelTypeEnum::CancelByUnderlyingMarket);
 
    quoteCancelRequest_->quoteCancelType(quoteCancelType);
 
    auto entry = quoteCancelRequest_->quoteEntries()[0];
 
    using OptSymbol = decltype(std::declval<const QuoteCancelRequest::QuoteEntry&>().underlyingSymbol());
    const auto underlyingSymbol = queryOptionalNumeric<OptSymbol>("UnderlyingSymbol");
 
    using OptSecId = decltype(std::declval<const QuoteCancelRequest::QuoteEntry&>().underlyingSecurityId());
    const auto secId = queryOptionalNumeric<OptSecId>("SecurityId");
 
    using OptProduct = decltype(std::declval<const QuoteCancelRequest::QuoteEntry&>().underlyingProduct());
    const auto product = queryOptionalNumeric<OptProduct>("Product");
 
    entry.underlyingSymbol(underlyingSymbol.raw());
    entry.underlyingSecurityId(secId.raw());
    entry.underlyingProduct(product.raw());
 
    TradingClient::send(bgwSession_, quoteCancelRequest_);
}
 
void TradingClient::createStrategy()
{
    checkConnected(bgwSession_, "BGW");
 
    constexpr size_t CreateStrategyMaxLegsCount = 5;
 
    MessageHolder<
        SecurityDefinitionRequest_CreateStrategy,
        getMaxMessageSize<SecurityDefinitionRequest_CreateStrategy>(CreateStrategyMaxLegsCount)> msg;
 
    msg->marketTypeId(queryNumeric("MarketTypeId", Default::MarketTypeId));
    msg->securityReqId(static_cast<Int32>(IdGenerator::newId() & 0xFFFFFFFFull));
    msg->securityRequestType(SecurityRequestTypeEnum::CreateStrategy);
    msg->securityType(SecurityTypeEnum::MLEG);
 
    using OptionalDate = decltype(std::declval<const SecurityDefinitionRequest_CreateStrategy&>().startDate());
    const auto startDate = queryOptionalTimestamp<OptionalDate>("StartDate");
    const auto endDate = queryOptionalTimestamp<OptionalDate>("EndDate");
 
    if(startDate)
         msg->startDate(*startDate);
    else
         msg->startDate(nullOpt);
 
    if(endDate)
         msg->endDate(*endDate);
    else
         msg->endDate(nullOpt);
 
    const auto legsCount = queryNumeric("Number of Legs", UInt32{2});
 
    assert(legsCount <= CreateStrategyMaxLegsCount);
 
    assert(std::distance(std::begin(Default::Symbols), std::end(Default::Symbols)) >= legsCount);
    auto defaultSymbol = std::begin(Default::Symbols);
 
    auto legs = msg->legs(legsCount);
 
    for(auto&& leg : legs)
    {
        leg.legSecurityType(SecurityTypeEnum::OPT);
 
        leg.legSymbol(queryNumeric("Symbol", *defaultSymbol));
 
        const auto side = querySide({SideEnum::Buy, SideEnum::Sell});
        leg.legSide(side);
 
        using OptDenominator = decltype(std::declval<const std::decay<decltype(leg)>::type>().legRatioQtyDenominator());
        const auto denominator = queryOptionalNumeric<OptDenominator>("LegRatioQtyDenominator");
 
        using OptNuminator = decltype(std::declval<const std::decay<decltype(leg)>::type>().legRatioQtyNumerator());
        const auto numerator = queryOptionalNumeric<OptNuminator>("LegRatioQtyNumerator");
 
        leg.legRatioQtyDenominator(denominator.raw());
        leg.legRatioQtyNumerator(numerator.raw());
 
        ++defaultSymbol;
    }
 
    TradingClient::send(bgwSession_, msg);
}
 
void TradingClient::createFlex()
{
    checkConnected(bgwSession_, "BGW");
 
    MessageHolder<SecurityDefinitionRequest_CreateFlex> msg;
    msg->securityRequestType(SecurityRequestTypeEnum::CreateFlexOption);
    msg->securityReqId(static_cast<Int32>(IdGenerator::newId()));
 
    const auto marketTypeId = queryNumeric("MarketTypeId", Default::MarketTypeId);
    const auto type = queryEnum("SecurityType", {SecurityTypeEnum::OPT, SecurityTypeEnum::FUT, SecurityTypeEnum::MLEG}, SecurityTypeEnum::OPT);
 
    using OptionalDate = decltype(std::declval<const SecurityDefinitionRequest_CreateFlex&>().maturityDate());
    const auto maturityDate = queryOptionalTimestamp<OptionalDate>("MaturityDate");
 
    using OptionalProductId = decltype(std::declval<const SecurityDefinitionRequest_CreateFlex&>().productId());
    const auto productId = queryOptionalNumeric<OptionalProductId>("ProductId");
 
    using OptionalSymbol = decltype(std::declval<const SecurityDefinitionRequest_CreateFlex&>().symbol());
    const auto symbol = queryOptionalNumeric<OptionalSymbol>("Symbol");
 
    using OptionalPrice = decltype(std::declval<const SecurityDefinitionRequest_CreateFlex&>().strikePrice());
    const auto price = queryOptionalDecimal<OptionalPrice>("StrikePrice");
 
    msg->securityType(type);
    msg->marketTypeId(marketTypeId);
    msg->productId(productId.raw());
    msg->symbol(symbol.raw());
    msg->strikePrice(price.raw());
 
    if(maturityDate)
        msg->maturityDate(*maturityDate);
    else
        msg->maturityDate(nullOpt);
 
    TradingClient::send(bgwSession_, msg);
}
 
CrossOrderPtr TradingClient::newOrderCross()
{
    auto crossOrder = std::make_shared<CrossOrder>();
 
    Order& buySideOrder = *crossOrder->buySideOrder_;
    Order& sellSideOrder = *crossOrder->sellSideOrder_;
 
    const auto symbol = queryNumeric("Symbol", Default::Symbol);
    buySideOrder.securityId_ = symbol;
    sellSideOrder.securityId_ = symbol;
 
    const auto ordType = queryOrderType({OrderTypeEnum::Market, OrderTypeEnum::Limit}, OrderTypeEnum::Limit);
 
    buySideOrder.ordType_ = ordType;
    sellSideOrder.ordType_ = ordType;
 
    if (ordType == OrderTypeEnum::Limit)
    {
        const auto price = queryDecimal("Price", 64570000);
        buySideOrder.price_ = price;
        sellSideOrder.price_ = price;
    }
 
    const auto qti = queryDecimal("Quantity", Default::QuantityMantissa);
    buySideOrder.orderQty_ = qti;
    buySideOrder.leavesQty_ = buySideOrder.orderQty_;
    sellSideOrder.orderQty_ = qti;
    sellSideOrder.leavesQty_ = sellSideOrder.orderQty_;
 
    buySideOrder.timeInForce_ = TimeInForceEnum::FAK;
    sellSideOrder.timeInForce_ = TimeInForceEnum::FAK;
 
    buySideOrder.side_ = SideEnum::Buy;
    sellSideOrder.side_ = SideEnum::Sell;
 
    return crossOrder;
}
 
OrderPtr TradingClient::newOrder(const Order* base)
{
    OrderPtr result = std::make_shared<Order>();
    auto& order = *result;
 
    order.securityId_ = queryNumeric("Symbol", base ? base->securityId_ : Default::Symbol);
 
    order.ordType_ = queryOrderType(
            {OrderTypeEnum::Market, OrderTypeEnum::Limit, OrderTypeEnum::Stop, OrderTypeEnum::StopLimit},
            base ? base->ordType_ : OrderTypeEnum::Limit);
 
    if (order.ordType_ == OrderTypeEnum::Limit || order.ordType_ == OrderTypeEnum::StopLimit)
        order.price_ = queryDecimal("Price", Default::PriceMantissa);
 
    if (order.ordType_ == OrderTypeEnum::StopLimit || order.ordType_ == OrderTypeEnum::Stop)
        order.stopPx_ = queryDecimal("StopPx", Default::PriceMantissa);
 
    order.orderQty_ = queryDecimal("Quantity", Default::QuantityMantissa);
    order.leavesQty_ = order.orderQty_;
 
    order.timeInForce_ = queryTimeInForce(
        {TimeInForceEnum::Day, TimeInForceEnum::GTC, TimeInForceEnum::FAK, TimeInForceEnum::FOK, TimeInForceEnum::GTD},
        base ? base->timeInForce_ : TimeInForceEnum::Day );
 
    if (order.timeInForce_ == TimeInForceEnum::GTD)
        order.expireDate_ = queryTimestamp("ExpireDate", (base && base->expireDate_) ? *base->expireDate_ : Default::Timestamp);
 
    order.side_ = querySide({SideEnum::Buy, SideEnum::Sell}, base ? base->side_ : SideEnum::Buy);
 
    order.execInst_ = queryExecInstOptional({ExecInstEnum::AON}, base ? base->execInst_ : Order::ExecInstOptional{nullOpt});
 
    const auto maxShow =
            queryOptionalDecimal("MaxShow", base ? base->maxShow_ : Order::QtiOptional{nullOpt});
 
    if(maxShow != nullOpt)
    {
        if(*maxShow > order.orderQty_)
            throw std::logic_error("Invalid `MaxShow` for order");
 
        order.maxShow_ = *maxShow;
    }
 
    return result;
}
 
void TradingClient::showOrders()
{
    ListViewer::outputItems(orderBook_.getEntries(), print, 10);
}
 
bool activeOrder(const Order& order) noexcept
{
    return order.orderStatus_ == ExecTypeEnum::New || order.orderStatus_ == ExecTypeEnum::PartialFill || order.orderStatus_ == ExecTypeEnum::Replaced;
}
 
void TradingClient::showActiveOrders()
{
    ListViewer::outputItems(orderBook_.getEntries(activeOrder), print, 10);
}
 
void TradingClient::cancelOrder()
{
    checkConnected(bgwSession_, "BGW");
 
    const auto ordersInBook = orderBook_.getEntries(activeOrder);
 
    if (ordersInBook.empty())
    {
        Screen::warning("No active orders found");
        return;
    }
 
    ListViewer::outputItems(ordersInBook, print);
 
    Screen::out("Enter the index of the order to be canceled");
 
    const auto orderIndex = Screen::getInput<size_t>();
    const Order& order = *ordersInBook.at(orderIndex - 1);
 
    cancelRequest_->
        clOrdId(IdGenerator::newId())
        .origClOrdId(order.cIOrdId_)
        .symbol(order.securityId_)
        .side(order.side_)
        ;
 
    TradingClient::send(bgwSession_, cancelRequest_);
}
 
void TradingClient::replaceOrder()
{
    checkConnected(bgwSession_, "BGW");
 
    const auto ordersInBook = orderBook_.getEntries(activeOrder);
 
    if (ordersInBook.empty())
    {
        Screen::warning("No active orders found");
        return;
    }
 
    ListViewer::outputItems(ordersInBook, print);
 
    Screen::out("Enter the index of the order to be replaced");
 
    const auto orderIndex = Screen::getInput<size_t>();
    const auto order = ordersInBook.at(orderIndex - 1);
 
    auto replaceOrder = orderBook_.store(newOrder(order.get()));
    replaceOrder.origCIOrdId_ = order->cIOrdId_;
 
    Screen::info(replaceOrder.toString());
 
    replaceRequest_->price(replaceOrder.price_.raw())
        .orderQty(replaceOrder.orderQty_)
        .symbol(replaceOrder.securityId_)
        .clOrdId(replaceOrder.cIOrdId_)
        .stopPx(replaceOrder.stopPx_.raw())
        .ordType(replaceOrder.ordType_)
        .timeInForce(replaceOrder.timeInForce_)
        .side(replaceOrder.side_)
        .origClOrdId(replaceOrder.origCIOrdId_)
        .maxShow(replaceOrder.maxShow_.raw());
 
    if (replaceOrder.timeInForce_ == TimeInForceEnum::GTD && replaceOrder.expireDate_)
        replaceRequest_->expireDate(*replaceOrder.expireDate_);
    else
        replaceRequest_->expireDate(nullOpt);
 
    TradingClient::send(bgwSession_, replaceRequest_);
}
 
void TradingClient::onNewOrderCrossReport(const Messaging::NewOrderCrossReport msg, Session* sn)
{
    Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
 
    if(hasFlag(msg.headerFlags(), HeaderFlags::PossDupe | HeaderFlags::PossResend))
        return;
 
    const auto status = msg.rfcStatus();
    if(status == RFCStatusEnum::None || status == RFCStatusEnum::Success)
        return;
 
    const auto crossId = msg.crossId();
    auto crossOrder = orderBook_.findCross(crossId);
 
    if (!crossOrder)
    {
        CUI::Screen::warning("No cross with id=", crossId, " is found");
        return;
    }
 
    auto& buySideOrder = *(crossOrder->get()->buySideOrder_);
    auto& sellSideOrder = *(crossOrder->get()->sellSideOrder_);
 
    if(status == RFCStatusEnum::PartialSuccessBidFailure || status == RFCStatusEnum::Failure)
    {
        buySideOrder.orderStatus_ = ExecTypeEnum::Rejected;
        Screen::info("Order changed: " + buySideOrder.toString());
    }
 
    if(status == RFCStatusEnum::PartialSuccessOfferFailure || status == RFCStatusEnum::Failure)
    {
        sellSideOrder.orderStatus_ = ExecTypeEnum::Rejected;
        Screen::info("Order changed: " + sellSideOrder.toString());
    }
}
 
void TradingClient::onExecutionReport_New(const Messaging::ExecutionReport_New msg, Session* sn)
{
     Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
 
     if(hasFlag(msg.headerFlags(), HeaderFlags::PossDupe | HeaderFlags::PossResend))
         return;
 
    if(auto order = findByOrderId(msg.clOrdId()))
    {
        setOrdStatus(**order, msg, ExecTypeEnum::New);
        setCommonMessageFields(**order, msg);
 
        Screen::info("Order changed: " + order->get()->toString());
    }
}
 
void TradingClient::onExecutionReport_Reject(const Messaging::ExecutionReport_Reject msg, Session* sn)
{
     Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
 
     if(hasFlag(msg.headerFlags(), HeaderFlags::PossDupe | HeaderFlags::PossResend))
         return;
 
    if(msg.rejectResponseTo() == RejectResponseToEnum::NewOrder)
    {
        if(auto order = findByOrderId(msg.clOrdId()))
        {
            setOrdStatus(**order, msg, ExecTypeEnum::Rejected);
            setCommonMessageFields(**order, msg);
 
            Screen::info("Order changed: " + order->get()->toString());
        }
    }
}
 
void TradingClient::onExecutionReport_Cancel(const Messaging::ExecutionReport_Cancel msg, Session* sn)
{
     Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
 
      if(hasFlag(msg.headerFlags(), HeaderFlags::PossDupe | HeaderFlags::PossResend))
         return;
 
    const auto origClOrdId = msg.origClOrdId();
 
    if(origClOrdId != nullOpt)
    {
        if(auto order = findByOrderId(*origClOrdId))
        {
            setOrdStatus(**order, msg, ExecTypeEnum::Cancelled);
            setCommonMessageFields(**order, msg);
 
            Screen::info("Order changed: " + order->get()->toString());
        }
    }
}
 
void TradingClient::onExecutionReport_Modify(const Messaging::ExecutionReport_Modify msg, Session* sn)
{
    Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
 
    if(hasFlag(msg.headerFlags(), HeaderFlags::PossDupe | HeaderFlags::PossResend))
        return;
 
    auto newOrder = findByOrderId(msg.clOrdId());
 
    const auto origClOrdId = msg.origClOrdId();
    auto oldOrder = origClOrdId ? findByOrderId(*origClOrdId) : decltype(findByOrderId(*origClOrdId)){};
 
    if(newOrder)
    {
        setOrdStatus(**newOrder, msg, ExecTypeEnum::New);
        setCommonMessageFields(**newOrder, msg);
 
        if(oldOrder)
            newOrder->get()->origCIOrdId_ = oldOrder->get()->cIOrdId_;
 
        Screen::info("Order changed: " + newOrder->get()->toString());
    }
 
    if(oldOrder)
        oldOrder->get()->orderStatus_ = ExecTypeEnum::Replaced;
}
 
void TradingClient::onExecutionReport_Trade(const Messaging::ExecutionReport_Trade msg, Session* sn)
{
     Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
 
      if(hasFlag(msg.headerFlags(), HeaderFlags::PossDupe | HeaderFlags::PossResend))
         return;
 
    if(auto order = findByOrderId(msg.clOrdId()))
    {
        setOrdStatus(**order, msg, msg.leavesQty() > 0 ? ExecTypeEnum::PartialFill : ExecTypeEnum::Fill);
 
        setCommonMessageFields(**order, msg);
        order->get()->lastPx_ = msg.lastPx();
 
        Screen::info("Order changed: " + order->get()->toString());
    }
}
 
void TradingClient::onExecutionReport_Snapshot(const Messaging::ExecutionReport_Snapshot msg, Session* sn)
{
    Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
 
    std::shared_ptr<Order> order;
    auto found = findByOrderId(msg.clOrdId());
 
    if(found)
        order = *found;
    else
        order = std::make_shared<Order>();
 
    const auto status = msg.orderStatus();
 
    if(status != nullOpt && (*status == OrderStatusEnum::New || *status == OrderStatusEnum::PartialFill))
    {
        if(*status == OrderStatusEnum::New)
            order->orderStatus_ = ExecTypeEnum::New;
        else if(*status == OrderStatusEnum::PartialFill)
            order->orderStatus_ = ExecTypeEnum::PartialFill;
 
        order->cIOrdId_ = msg.clOrdId();
        order->price_ = msg.price();
        order->orderQty_ = msg.leavesQty();
        order->leavesQty_ = msg.leavesQty();
        order->securityId_ = msg.symbol();
        order->side_ = msg.side();
        order->ordType_ = msg.ordType();
        order->stopPx_ = msg.stopPx();
        order->timeInForce_ = msg.timeInForce();
        order->expireDate_ = msg.expireDate();
        order->transactTime_ = msg.execId().transactTime();
        order->maxShow_ = msg.maxShow();
        order->execInst_ = msg.execInst();
        order->origCIOrdId_ = msg.clOrdId();
 
        if(!found)
            orderBook_.store(order);
    }
}
 
void TradingClient::onIPReport(const Messaging::IPReport msg, Session* sn)
{
    Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
 
    try
    {
        const auto users = msg.users();
 
        if(users.empty())
             throw std::runtime_error("'IPReport' message does not contain connectivity information.");
 
        Messaging::IPReport::UsersEntry entry = users[0];
 
        if (!(entry.success() && *entry.success() == Messaging::BooleanEnum::True))
            throw std::runtime_error("IPReport::UsersEntry is invalid: success flag is missing or not set to True.");
 
        if (!entry.ipAddress() || !entry.port() || !entry.ipSessionToken())
            throw std::runtime_error("Invalid 'IPReport::UsersEntry'");
 
        auto credentials = BgwCredentials(Messaging::toStr(*entry.ipAddress()), *entry.port(), Messaging::toStr(*entry.ipSessionToken()));
 
        bgwCredentials_ = credentials;
    }
    catch(std::exception& e)
    {
        Screen::error(e.what());
    }
}
 
void TradingClient::onSecurityDefinitionReport(const Messaging::SecurityDefinitionReport msg, Session* sn)
{
    if(sn == bgwSession_.get())
        Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
    else
        Screen::printProgress(msg.listSeqNo(), msg.rpts());
 
    std::shared_ptr<std::vector<uint8_t>> p(new std::vector<uint8_t>(msg.calculateBinarySize()));
    assert(p->size() == msg.calculateBinarySize());
    std::memcpy(p->data(), msg.binary(), p->size());
 
    instruments_.push_back(p);
}
 
void TradingClient::onSecurityDefinitionReport_Strategy(const Messaging::SecurityDefinitionReport_Strategy msg, Session* sn)
{
    if(sn == bgwSession_.get())
        Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::In);
    else
        Screen::printProgress(msg.listSeqNo(), msg.rpts());
 
    std::shared_ptr<std::vector<uint8_t>> p(new std::vector<uint8_t>(msg.calculateBinarySize()));
    assert(p->size() == msg.calculateBinarySize());
    std::memcpy(p->data(), msg.binary(), p->size());
 
    instruments_.push_back(p);
}
 
void TradingClient::onError(SessionErrorReason::Enum, const std::string & description, Session * sn, Messaging::SbeMessage)
{
    Screen::error("[" + sn->id() + "] error: [", description, "]");
}
 
void TradingClient::onWarning(SessionWarningReason::Enum, const std::string & description, Session * sn, Messaging::SbeMessage)
{
    Screen::warning("[" + sn->id() + "] warning: [", description, "]");
}
 
void TradingClient::onStateChange(SessionStateId::Enum newState, SessionStateId::Enum /*prevState*/, Session * sn)
{
    Screen::trace("[" + sn->id() + "] changed it's state to [", SessionStateId::toString(newState), "]");
}
 
void TradingClient::onMessageSending(char* bytes, size_t size, Session* sn)
{
    const auto msg = SbeMessage(bytes, static_cast<Messaging::MessageSize>(size));
 
    if(msg.templateId() != HeartBeat::TemplateId)
        CUI::Screen::traceMsg(sn->id(), msg, CUI::Screen::Direction::Out);
}
 
}

---

Book.h

/*
* 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 <string>
#include <vector>
#include <unordered_map>
#include <thread>
#include <mutex>
#include <functional>
 
#include "Order.h"
#include "Utils.h"
 
namespace Samples {

class Book
{
public:
    using BookEntryId = Order::OrderId;
    using BookEntries = std::unordered_map<BookEntryId, OrderPtr>;
    using Id2crossOrderMap = std::unordered_map<BookEntryId, CrossOrderPtr>;

    Order& store(OrderPtr entry);
    Order& store(OrderPtr entry, BookEntryId id);

    CrossOrder& store(CrossOrderPtr entry);

    OptionalRef<Order> find(BookEntryId id);

    OptionalRef<CrossOrder> findCross(BookEntryId id);

    using OrdersList = std::vector<OrderPtr>;
    OrdersList getEntries(std::function<bool(const Order&)> predicate = [](const Order&){ return true; });
 
private:
    using Mutex = std::recursive_mutex;
    using Guard = std::lock_guard<Mutex>;
 
    Mutex mutex_;
    BookEntries entries_;
    Id2crossOrderMap crossOrders_;
};
 
}

---

Order.h

/*
* 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/Messaging.h>
 
#include <string>
#include <array>
 
namespace Samples {
 
using namespace ONIXS_ICEBOE_NAMESPACE;
using namespace ONIXS_ICEBOE_MESSAGING_NAMESPACE;
 
struct Order
{
    using PriceOptional = decltype(std::declval<const NewOrderRequest&>().price());
    using Qty = decltype(std::declval<const NewOrderRequest&>().orderQty());
    using ClOrderId = decltype(std::declval<const NewOrderRequest&>().clOrdId());
 
    using SecurityId = decltype(std::declval<const NewOrderRequest&>().symbol());
    using OrderId = decltype(std::declval<const ExecutionReport_Trade&>().orderId());
 
    using TimestampOptional = decltype(std::declval<const NewOrderRequest&>().expireDate());
    using QtiOptional = decltype(std::declval<const NewOrderRequest&>().maxShow());
 
    using ExecInstOptional = decltype(std::declval<const NewOrderRequest&>().execInst());

    Order();

    std::string toString() const;

    OrderId id() const noexcept
    {
        return cIOrdId_;
    }
 
    ClOrderId cIOrdId_;
    ClOrderId origCIOrdId_{cIOrdId_};
    PriceOptional price_{};
    Qty orderQty_{};
    Qty leavesQty_{};
    SecurityId securityId_{};
    SideEnum side_{SideEnum::Buy};
    OrderTypeEnum ordType_{OrderTypeEnum::Limit};
    PriceOptional stopPx_{};
    TimeInForceEnum timeInForce_{TimeInForceEnum::Day};
    TimestampOptional expireDate_{};
    PriceOptional lastPx_{};
    TimestampOptional transactTime_{};
    ExecTypeEnum orderStatus_{ExecTypeEnum::New};
    QtiOptional maxShow_{};
    ExecInstOptional execInst_{};
};
 
using OrderPtr = std::shared_ptr<Order>;
 
inline auto print(OrderPtr order)
{
    return order ? order->toString() : toStr(nullOpt);
}

struct CrossOrder
{
    using Id = decltype(std::declval<const NewOrderCrossRequest&>().crossId());

    CrossOrder();

    Id id() const noexcept
    {
        return crossId_;
    }

    std::string toString() const;
 
    Id crossId_;
    OrderPtr buySideOrder_;
    OrderPtr sellSideOrder_;
};
 
using CrossOrderPtr = std::shared_ptr<CrossOrder>;
 
}

---

Order.cpp

/*
* 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.
*/
 
#include <OnixS/ICE/BOE/IceBoe.h>
 
#include "Order.h"
#include "Utils.h"
 
#include <Common/Helpers.h>
 
namespace Samples {
 
Order::Order()
    : cIOrdId_(IdGenerator::newId())
{
}
 
std::string toStr(Order::PriceOptional value)
{
    return (value != nullOpt) ? toStr(Decimal{*value, -9}) : toStr(nullOpt);
}
 
std::string Order::toString() const
{
    std::ostringstream builder;
 
    builder
        << "Order["
        << "ClOrdID=" << cIOrdId_
        << ", OrigCIOrdId=" << origCIOrdId_
        << ", OrderStatus=" << orderStatus_
        << ", SecurityId=" << securityId_
        << ", Type=" << ordType_
        << ", Price=" << toStr(price_)
        << ", Quantity=" << toStr(Decimal{orderQty_, -9})
        << ", LeavesQty=" << toStr(Decimal{leavesQty_, -9})
        << ", Side=" << side_
        << ", StopPx=" << toStr(stopPx_)
        << ", LastFillPrice=" << toStr(lastPx_)
        << ", TimeInForce=" << timeInForce_
        << ", ExpireDate=" << (timeInForce_ == TimeInForceEnum::GTD && expireDate_ != nullOpt ? toStr(*expireDate_, TimestampFormat::YYYYMMDD) : toStr(nullOpt))
        << ", TransactTime=" << (transactTime_ != nullOpt ? toStr(*transactTime_, TimestampFormat::YYYYMMDDHHMMSSnsec) : toStr(nullOpt))
        << ", MaxShow=" << toStr(maxShow_)
        << ", ExecInst=" << execInst_
        << "]"
        ;
 
    return builder.str();
}
 
CrossOrder::CrossOrder()
    : crossId_{IdGenerator::newId()}
    , buySideOrder_(std::make_shared<Order>())
    , sellSideOrder_(std::make_shared<Order>())
 
{
}
 
std::string CrossOrder::toString() const
{
    std::ostringstream builder;
    builder
        << "CrossOrder["
        << "CrossId=" << crossId_;
 
    builder << ", " << buySideOrder_->toString();
    builder << ", " << sellSideOrder_->toString();
 
    builder << "]";
    return builder.str();
}
 
}

---

Settings.h

/*
* 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/utils/ConfigurationParser.h>
#include <string>
 
namespace Samples {
 
using namespace ONIXS_ICEBOE_NAMESPACE;
 
class Settings
{
public:
    Settings() = default;
 
    Settings(const std::string& filename)
        : map_(System::ConfigurationParser::parseConfigFile(filename, "TradingClient"))
    {
    }
 
    template<typename T = std::string>
    T get(const std::string& key, typename std::enable_if<std::is_integral<T>::value, void*>::type = nullptr) const
    {
        return System::ConfigurationParser::Utils::fromString<T>((getAsStr(key)));
    }
 
    template<typename T = std::string>
    T get(const std::string& key, T defaultValue, typename std::enable_if<std::is_integral<T>::value, void*>::type = nullptr) const
    {
        const auto v = getIfAny(key);
        return v.empty() ? defaultValue : System::ConfigurationParser::Utils::fromString<T>(v);
    }
 
    template<typename T = std::string>
    T get(const std::string& key, typename std::enable_if<std::is_same<T, std::string>::value, void*>::type = nullptr) const
    {
        return getAsStr(key);
    }
 
    template<typename T = std::string>
    T get(const std::string& key, T defaultValue, typename std::enable_if<std::is_same<T, std::string>::value, void*>::type = nullptr) const
    {
        return getAsStr(key, defaultValue);
    }
 
    template<typename T = std::string>
    T get(const std::string& key, typename std::enable_if<std::is_same<T, bool>::value, void*>::type = nullptr) const
    {
        return System::ConfigurationParser::Utils::fromString<bool>(getAsStr(key));
    }
 
    template<typename T = std::string>
    T get(const std::string& key, T defaultValue, typename std::enable_if<std::is_same<T, bool>::value, void*>::type = nullptr) const
    {
        const auto v = getIfAny(key);
        return v.empty() ? defaultValue : System::ConfigurationParser::Utils::fromString<bool>(getAsStr(v));
    }
 
    bool isSet(const std::string& key) const
    {
        return map_.find(key) != map_.end();
    }
 
private:
    std::string getAsStr(const std::string& key) const
    {
        const auto it = map_.find(key);
 
        if (it == map_.end())
            throw std::domain_error("There is no setting '" + key +"' available.");
 
        return it->second;
    }
 
    std::string getAsStr(const std::string& key, const std::string& defaultValue) const
    {
        const auto it = map_.find(key);
        return (it == map_.end()) ? defaultValue : it->second;
    }
 
    std::string getIfAny(const std::string& key) const
    {
        return getAsStr(key, {});
    }
 
private:
    const System::ConfigurationParser::KeyValueMap map_;
};
 
}

---

Utils.h

/*
* 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/ABI.h>
#include <OnixS/ICE/BOE/messaging/Utils.h>
#include <OnixS/ICE/BOE/messaging/Messages.h>
 
#include "Order.h"
 
#include <istream>
#include <sstream>
 
#ifdef ONIXS_ICEBOE_CXX17
#  include <optional>
#endif
 
namespace Samples {
 
using namespace ONIXS_ICEBOE_NAMESPACE;
using namespace ONIXS_ICEBOE_MESSAGING_NAMESPACE;
 
namespace details {
 
template<typename T>
struct hasTransactTimeImpl
{
    template<typename U, Timestamp (U::*)() const> struct SFINAE {};
    template<typename U> static char test(SFINAE<U, &U::transactTime>*);
 
#if ONIXS_ICEBOE_CXX17_NOEXCEPT
    template<typename U, Timestamp (U::*)() const noexcept> struct SFINAE_1 {};
    template<typename U> static char test(SFINAE_1<U, &U::transactTime>*);
#endif
 
    template<typename U> static int test(...);
    static constexpr bool value = sizeof(test<T>(nullptr)) == sizeof(char);
};
 
template<typename T>
struct hasExecIdImpl
{
    template<typename U, OrderExecID (U::*)() const noexcept> struct SFINAE {};
    template<typename U> static char test(SFINAE<U, &U::execId>*);
    template<typename U> static int test(...);
    static constexpr bool value = sizeof(test<T>(nullptr)) == sizeof(char);
};
 
template<typename T>
struct hasExecTypeImpl
{
    template<typename U, typename V, V (U::*)() const noexcept> struct SFINAE {};
    template<typename U> static char test(SFINAE<U, decltype(std::declval<const U&>().execType()), &U::execType>*);
    template<typename U> static int test(...);
    static constexpr bool value = sizeof(test<T>(nullptr)) == sizeof(char);
};
 
 
template<typename T>
struct hasLeavesQtyImpl
{
    template<typename U, typename V, V (U::*)() const noexcept> struct SFINAE {};
    template<typename U> static char test(SFINAE<U, decltype(std::declval<const U&>().leavesQty()), &U::leavesQty>*);
    template<typename U> static int test(...);
    static constexpr bool value = sizeof(test<T>(nullptr)) == sizeof(char);
};
 
}
 
template<class T> using hasTransactTime = typename details::hasTransactTimeImpl<cleanType<T>>;
template<class T> using hasExecId = typename details::hasExecIdImpl<cleanType<T>>;
template<class T> using hasExecType = typename details::hasExecTypeImpl<cleanType<T>>;
template<class T> using hasLeavesQty = typename details::hasLeavesQtyImpl<cleanType<T>>;
 
template <typename MsgType>
Timestamp getTransactTime(MsgType&& msg, typename std::enable_if<hasTransactTime<MsgType>::value, void*>::type = nullptr)
{
    return msg.transactTime();
}
 
template <typename MsgType>
Timestamp getTransactTime(MsgType&& msg, typename std::enable_if<!hasTransactTime<MsgType>::value && hasExecId<MsgType>::value, void*>::type = nullptr)
{
    return msg.execId().transactTime();
}
 
template <typename MsgType>
Timestamp getTransactTime(MsgType&&, typename std::enable_if<!hasTransactTime<MsgType>::value && !hasExecId<MsgType>::value, void*>::type = nullptr)
{
    return Timestamp{};
}
 
template <typename MsgType>
ExecTypeEnum getOrdStatus(MsgType&& msg, ExecTypeEnum, typename std::enable_if<hasExecType<MsgType>::value, void*>::type=nullptr)
{
    return msg.execType();
}
 
template <typename MsgType>
ExecTypeEnum getOrdStatus(MsgType&&, ExecTypeEnum defaultValue, typename std::enable_if<!hasExecType<MsgType>::value, void*>::type=nullptr)
{
    return defaultValue;
}
 
template <typename MsgType>
void setOrdStatus(Order& order, MsgType&& msg, ExecTypeEnum defaultValue)
{
    order.orderStatus_ = getOrdStatus(msg, defaultValue);
}
 
template <typename MsgType>
void setLeavesQty(Order& order, MsgType&& msg, typename std::enable_if<hasLeavesQty<MsgType>::value, void*>::type=nullptr)
{
    order.leavesQty_ = msg.leavesQty();
}
 
template <typename MsgType>
void setLeavesQty(Order&, MsgType&&, typename std::enable_if<!hasLeavesQty<MsgType>::value, void*>::type=nullptr) {}
 
inline Decimal9 toPriceMantissa(Decimal value)
{
    return quantize(value, -9).mantissa();
}
 
template <typename T>
T parseUserInput(const std::string& userInput, typename std::enable_if<std::is_integral<T>::value, void*>::type = nullptr)
{
    std::istringstream ss{userInput};
    ss >> std::ws;
 
    using Wide = typename std::conditional<std::is_signed<T>::value, long long, unsigned long long>::type;
    Wide converted{};
 
    if (!(ss >> converted))
        throw std::invalid_argument("Invalid user input: '" + userInput + "'");
 
    return static_cast<T>(converted);
}
 
template <typename T>
T parseUserInput(const std::string& userInput, typename std::enable_if<isScopedEnum<T>::value, void*>::type = nullptr)
{
    std::istringstream ss{userInput};
    ss >> std::ws;
 
    using Wide =
            typename std::conditional<
            std::is_same<typename underlyingType<T>::type, char>::value,
                char,
                typename std::conditional<std::is_signed<T>::value,
                    long long,
                    unsigned long long>::type>::type;
 
    Wide converted{};
 
    if (!(ss >> converted))
        throw std::invalid_argument("Invalid user input: '" + userInput + "'");
 
    const auto enumerated = static_cast<T>(static_cast<typename underlyingType<T>::type>(converted));
 
    if(ONIXS_ICEBOE_MESSAGING_NAMESPACE::toStr(enumerated).find("UNKNOWN_VALUE") != std::string::npos)
        throw std::invalid_argument("Invalid user input: '" + userInput + "'");
 
    return enumerated;
}
 
template <typename T>
Decimal parseUserInput(const std::string& userInput, typename std::enable_if<std::is_floating_point<T>::value, void*>::type = nullptr)
{
    Decimal value;
 
    if(fromStr(value, userInput))
        return value;
 
    throw std::invalid_argument("Invalid user input: '" + userInput + "'");
}
 
template <typename T>
T parseUserInput(const std::string& userInput, typename std::enable_if<std::is_same<T, std::string>::value, void*>::type = nullptr)
{
    return userInput;
}
 
 
template <typename T>
auto toValueNamePair(T v, typename std::enable_if<isScopedEnum<T>::value, void*>::type=nullptr)
{
    return toStr(toUnderlying(v)) + "-" + toStr(v);
}
 
template <typename It>
inline auto join(It first, It last, char delim, typename std::enable_if<isScopedEnum<typename It::value_type>::value, void*>::type=nullptr)
{
    if (first == last)
        return std::string{};
 
    std::ostringstream oss;
    oss << toValueNamePair(*first);
    ++first;
    for (; first != last; ++first)
        oss << delim << toValueNamePair(*first);
 
    return oss.str();
}

#ifdef ONIXS_ICEBOE_CXX17
template<typename T> using OptionalRef = std::optional<std::shared_ptr<T>>;
#else
template <typename T>
class OptionalRef
{
    using Ref = std::shared_ptr<T>;
 
public:
    OptionalRef() noexcept : has_(false) {}
 
    explicit OptionalRef(std::shared_ptr<T> t)
        : has_(true)
    {
        ::new (&storage_) Ref(t);
    }
 
    OptionalRef(const OptionalRef& o)
        : has_(o.has_)
    {
        if (has_) ::new (&storage_) Ref(*o.refptr());
    }
 
    OptionalRef(OptionalRef&& o) noexcept
        : has_(o.has_)
    {
        if (has_) ::new (&storage_) Ref(std::move(*o.refptr()));
    }
 
    ~OptionalRef() { if (has_) { refptr()->~Ref(); } }
 
    explicit operator bool() const noexcept { return has_; }
 
    Ref& operator*() { return value(); }
    const Ref& operator*() const { return value(); }
 
    Ref* operator->() { return &value(); }
    const Ref* operator->() const { return &value(); }
 
private:
    Ref* refptr() { return reinterpret_cast<Ref*>(&storage_); }
    const Ref* refptr() const { return reinterpret_cast<const Ref*>(&storage_); }
    Ref& value() { if (!has_) throwBadOptionalAccess(); return *refptr(); }
    const Ref& value() const { if (!has_) throwBadOptionalAccess(); return *refptr(); }
 
    using Storage = typename std::aligned_storage<sizeof(Ref), alignof(Ref)>::type;
 
    bool has_;
    Storage storage_;
};
#endif
 
}

---

CUI.h

/*
* 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/messaging/Typification.h>
#include <OnixS/ICE/BOE/messaging/SbeMessage.h>
#include <OnixS/ICE/BOE/messaging/Utils.h>
 
#include "Book.h"
#include "Utils.h"
 
#include <sstream>
#include <iostream>
#include <string>
#include <vector>
#include <thread>
#include <chrono>
#include <iomanip>
 
#ifdef _WIN32
#include <windows.h>
#endif
 
namespace CUI {
 
using namespace ONIXS_ICEBOE_NAMESPACE;
using namespace ONIXS_ICEBOE_MESSAGING_NAMESPACE;

struct Screen
{
    static void init()
    {
#ifdef _WIN32
        vtMode() = enableVtMode();
#endif
    }
 
    struct DeleteLast {size_t n;};
    inline static DeleteLast deleteLast(size_t n) {return {n};}
 
    inline friend std::ostream& operator<<(std::ostream& os, const DeleteLast& m)
    {
        if(vtMode()) os << "\x1b[" << m.n << "F" << "\x1b[" << m.n << "M" << std::flush;
        return os;
    }
 
    static std::ostream& reset(std::ostream& os)
    {
        if(vtMode()) os << "\x1b[0m";
        return os;
    }
 
    static std::ostream& bold(std::ostream& os)
    {
        if(vtMode()) os << "\x1b[1m";
        return os;
    }
 
    static std::ostream& red(std::ostream& os)
    {
        if(vtMode()) os << "\x1b[38;2;255;64;64m";
        return os;
    }
 
    static std::ostream& green(std::ostream& os)
    {
        if(vtMode()) os << "\x1b[38;2;0;255;64m";
        return os;
    }
 
    static std::ostream& yellow(std::ostream& os)
    {
        if(vtMode()) os << "\x1b[38;2;255;255;64m";
        return os;
    }
 
    static std::ostream& black(std::ostream& os)
    {
        if(vtMode()) os << "\x1b[30m";
        return os;
    }
 
    static std::ostream& onRed (std::ostream& os)
    {
        if(vtMode()) os << "\x1b[48;2;210;120;120m";
        return os;
    }
 
    static std::ostream& onGreen (std::ostream& os)
    {
        if(vtMode()) os << "\x1b[48;2;120;200;150m";
        return os;
    }
 
    static std::ostream& onYellow(std::ostream& os)
    {
        if(vtMode()) os << "\x1b[48;2;235;220;160m";
        return os;
    }
 
    static std::ostream& onCyan  (std::ostream& os)
    {
        if(vtMode()) os << "\x1b[48;2;150;210;220m";
        return os;
    }
 
    static std::ostream& onWhite (std::ostream& os)
    {
        if(vtMode()) os << "\x1b[48;2;240;240;240m";
        return os;
    }
 
    static std::ostream& out()
    {
        return std::cout;
    }
 
    template<typename T>
    static T getInput(const T& defaultValue = {})
    {
        std::string userInput;
        std::getline(std::cin, userInput);
 
        if (userInput.empty())
            return defaultValue;
 
        return Samples::parseUserInput<T>(userInput);
    }
 
    template<typename... Args>
    static void info(const Args&... args)
    {
        Guard g(mutex(), out());
        out() << "\n"  << bold << black << onGreen << "[INFO]" << reset << " " << append(args...) << "\n";
    }
 
    template<typename... Args>
    static void error(const Args&... args)
    {
        Guard g(mutex(), out());
        out() << "\n"  << bold << black << onRed << "[ERROR]" << reset << " " << append(args...) << "\n";
    }
 
    template<typename... Args>
    static void warning(const Args&... args)
    {
        Guard g(mutex(), out());
        out() << "\n"  << bold << black << onYellow << "[WARN]" << reset << " " << append(args...) << "\n";
    }
 
    template<typename... Args>
    static void trace(const Args&... args)
    {
        Guard g(mutex(), out());
        out() << "\n"  << bold << black << onCyan << "[TRACE]" << reset << " " << append(args...)  << "\n";
    }
 
    template<typename... Args>
    static void out(const Args&... args)
    {
        Guard g(mutex(), out());
        out() << append(args...) << std::endl;
    }
 
    static void printProgress(size_t cur, size_t total)
    {
        Guard g(mutex(), out());
 
        const size_t width = 40;
 
        if (total == 0) total = 1;
        cur = (std::min)(cur, total);
 
        const double r = double(cur) / double(total);
        const auto filled = static_cast<std::size_t>(r * width);
 
        out() << '\r' << '[' << std::string(filled, '#') << std::string(width - filled, ' ')
                  << "] " << std::setw(3) << int(r * 100) << '%' << std::flush;
 
        if (cur == total) out() << '\n';
    }
 
    enum class Direction {In, Out};
 
    static std::string toStr(Direction direction)
    {
#ifdef _WIN32
        return direction == Direction::In ? "[<-]" : "[->]";
#else
        return direction == Direction::In ? "[←]" : "[→]";
#endif
    }
 
    static void traceMsg(const std::string& sessionId, SbeMessage message, Direction direction)
    {
        Guard g(mutex(), out());
 
        out() << "\n" << bold << black << onCyan << toStr(direction) << reset << " ";
 
        out() << "[" << sessionId << "] ";
 
        const auto printMsg = [&](const auto msg)
        {
            out() << msg.toString();
 
            const auto text = formatMsg(msg);
 
            if(!text.empty())
                 out() << "\n\t" << text;
        };
 
        if (!ONIXS_ICEBOE_MESSAGING_NAMESPACE::processTypified(message, printMsg))
            out() << yellow << "Unknown message type [" << message.templateId() << "]" << reset;
 
        out() << "\n";
    }
 
    template <typename ItemType>
    static void outItems(const ItemType & items)
    {
        Guard g(mutex(), out());
 
        for (size_t index = 0; index < items.size(); ++index)
            out() << "\t" << bold << black << onGreen << "[" << (index + 1) << "]" << reset << " " << items[index].text_ << "\n";
    }
 
    template <typename ItemType>
    static void outList(const ItemType & list)
    {
        Guard g(mutex(), out());
 
        out() << "\t[";
 
        bool first = true;
        for (const auto& item : list)
        {
            if (!first)
                out() << ",";
 
            first = false;
            out() << item;
        }
 
        out() << "]\n";
    }
 
    static std::chrono::milliseconds sinceLstUpdate()
    {
        return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - lastUpdateTime());
    }
 
private:
    template<typename T>
    static void appendToStream(std::ostringstream& oss, const T& value)
    {
        oss << value;
    }
 
    template<typename T, typename... Args>
    static void appendToStream(std::ostringstream& oss, const T& value, const Args&... args)
    {
        oss << value;
        appendToStream(oss, args...);
    }
 
    template <typename... Args>
    static auto append(const Args&... args)
    {
        std::ostringstream oss;
        appendToStream(oss, args...);
        return oss.str();
    }
 
#ifdef _WIN32
    static bool enableVtMode()
    {
        const HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
        if (h == INVALID_HANDLE_VALUE)
            return false;
 
        DWORD mode = 0;
        if (!GetConsoleMode(h, &mode))
            return false;
 
        mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
 
        return SetConsoleMode(h, mode) != 0;
    }
#endif
    static bool& vtMode()
    {
        static bool value = true;
        return value;
    }
 
    using Mutex = std::recursive_mutex;
 
    struct Guard : public std::lock_guard<Mutex>
    {
         Guard(Mutex& mutex, std::ostream& s)
            : std::lock_guard<Mutex>(mutex)
            , s_(s)
        {}
 
        ~Guard()
        {
             try { s_ << reset << std::flush; } catch(...){}
             setLastUpdateTime();
        }
 
        std::ostream& s_;
    };
 
    static Mutex& mutex()
    {
        static Mutex mutex;
        return mutex;
    }
 
    static std::chrono::time_point<std::chrono::steady_clock>& lastUpdateTime()
    {
        static auto lastUpdateTime = std::chrono::steady_clock::now();
        return lastUpdateTime;
    }
 
    static void setLastUpdateTime()
    {
        lastUpdateTime() = std::chrono::steady_clock::now();
    }
};
 
using Command = std::function<void()>;

struct MenuItem
{
    MenuItem(const std::string& text, const std::string& commandText, const std::initializer_list<Command>& items)
        : text_(text)
        , commandText_(commandText)
        , commands_{items}
    {}
 
    MenuItem(const std::string& text, const std::string& commandText, const Command& command)
        : text_(text)
        , commandText_(commandText)
        , commands_{command}
    {}
 
    std::string text_;
    std::string commandText_;
 
    std::vector<Command> commands_;
};

class Menu
{
public:
    Menu(const std::initializer_list<MenuItem>& items)
        : items_{items}
    {
        Screen::init();
        outputItems();
    }

    void processRequests() const
    {
        while (!stopRequested_)
            processRequest();
    }

    void outputItems() const
    {
        Screen::info("Commands:");
        Screen::outItems(items_);
    }

    void stopRequest() noexcept
    {
        stopRequested_ = true;
    }
 
private:
    bool stopRequested_ = false;

    std::vector<MenuItem> items_;

    void processRequest() const
    {
        static const auto CommandExecutionTimeout = std::chrono::milliseconds(500);
 
        if(Screen::sinceLstUpdate() < CommandExecutionTimeout)
            return;
 
        Screen::info("Select operation to perform. Enter a choice (1 - Show options):");
 
        size_t selectedItemNumber = 0;
        while (true)
        {
            try
            {
                const auto userInput = Screen::getInput<size_t>();
                Screen::out() << Screen::deleteLast(3);
                selectedItemNumber = userInput - 1;
            }
            catch(...)
            {
                continue;
            }
 
            if(selectedItemNumber < items_.size())
                break;
 
            Screen::warning("Invalid command requested. Repeat a choice (1 - Show options):");
        }
 
        try
        {
            const auto& selectedItem = items_[selectedItemNumber];
 
            Screen::info(selectedItem.commandText_ + "...");
 
            const auto commands = selectedItem.commands_;
            for(auto command : commands)
            {
                command();
 
                if(stopRequested_)
                    return;

                std::this_thread::sleep_for(CommandExecutionTimeout);
            }
        }
        catch (const std::exception& ex)
        {
            Screen::error(ex.what());
        }
    }
 
friend struct ListViewer;
};
 
struct ListViewer
{
    template <typename EntryList, typename Print>
    static void outputItems(const EntryList& items, Print print = [](auto item){ return toStr(item);}, size_t itemsPerPage = 100)
    {
        if (items.empty())
        {
            Screen::info("[]");
            return;
        }
 
        size_t itemsToOutput = itemsPerPage;
 
        std::size_t n = 0;
        for (const auto& item : items)
        {
            if (0 == --itemsToOutput)
            {
                itemsToOutput = itemsPerPage;
 
                if (!shouldContinue())
                    return;
            }
 
            Screen::out() << "\n"
                << Screen::bold << Screen::black << Screen::onCyan << "[" << std::to_string(++n) << "]"
                << Screen::reset << " " << print(item)  << "\n";
        }
    }
 
private:
    static bool shouldContinue()
    {
        Screen::info("Press <Enter> to view next page or Enter 'q' to abort current action: ");
        const auto userInput = Screen::getInput<std::string>();
 
        return userInput.empty();
    }
};
 
}

---