TradingClient Class Reference

Public Member Functions
	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 ()

Detailed Description

Definition at line 45 of file TradingClient.h.

Constructor & Destructor Documentation

TradingClient()

TradingClient ( const Settings & settings )

explicit

Initializes the client with the given settings.

Definition at line 468 of file TradingClient.cpp.

    : 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))
{
}

Member Function Documentation

cancelOrder()

void cancelOrder

(

)

Sends a cancel request for a specific order.

Definition at line 1063 of file TradingClient.cpp.

{
    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_);
}

connectBgw()

void connectBgw

(

)

Establishes a BGW session using previously obtained credentials.

Definition at line 575 of file TradingClient.cpp.

{
    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());
}

connectBus()

void connectBus

(

)

Commands.

Establishes a BUS session (network/control plane).

Definition at line 493 of file TradingClient.cpp.

{
    auto settings = sessionSettings_;
 
    if(!busSession_)
        busSession_.reset(new Session(SessionType::BUS, settings, this));
 
    busSession_->connect(settings_.get("Host"), settings_.get<Port>("Port"));
}

createFlex()

void createFlex

(

)

Creates a flexible instrument (flex).

Definition at line 928 of file TradingClient.cpp.

{
    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);
}

createStrategy()

void createStrategy

(

)

Creates a strategy.

Definition at line 866 of file TradingClient.cpp.

{
    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);
}

listInstruments()

void listInstruments

(

)

Prints the list of instruments currently known to the client.

Definition at line 538 of file TradingClient.cpp.

{
    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);
}

lookupInstruments()

void lookupInstruments

(

)

Prints the list of instruments currently known to the client by the provided Symbol value.

Definition at line 558 of file TradingClient.cpp.

{
    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);
}

replaceOrder()

void replaceOrder

(

)

Issues a replace for an existing live order.

Definition at line 1092 of file TradingClient.cpp.

{
    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_);
}

requestBgwCredentials()

void requestBgwCredentials

(

)

Requests BGW credentials (IpRequest) over the active BUS session.

Definition at line 503 of file TradingClient.cpp.

{
    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);
}

requestInstruments()

void requestInstruments

(

)

Submits a SecurityDefinitionRequest to fetch/refresh known instruments.

Definition at line 517 of file TradingClient.cpp.

{
    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);
}

sendMassCancel()

void sendMassCancel

(

)

Submits a mass cancel request.

Definition at line 736 of file TradingClient.cpp.

{
    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_);
}

sendMassQuote()

void sendMassQuote

(

)

Sends a multiple quote request.

Definition at line 802 of file TradingClient.cpp.

{
    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_);
}

sendOrder()

void sendOrder

(

)

Sends a new order via BGW.

Definition at line 615 of file TradingClient.cpp.

{
    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_);
}

sendOrderCross()

void sendOrderCross

(

)

Sends a cross order.

Definition at line 665 of file TradingClient.cpp.

{
    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_);
}

sendQuote()

void sendQuote

(

)

Sends a quote message.

Definition at line 773 of file TradingClient.cpp.

{
    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_);
}

sendQuoteCancelRequest()

void sendQuoteCancelRequest

(

)

Cancels a previously submitted quote.

Definition at line 835 of file TradingClient.cpp.

{
    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_);
}

showActiveOrders()

void showActiveOrders

(

)

Displays active orders sent by this client session and their last-known statuses.

Definition at line 1058 of file TradingClient.cpp.

{
    ListViewer::outputItems(orderBook_.getEntries(activeOrder), print, 10);
}

showOrders()

void showOrders

(

)

Displays orders sent by this client session and their last-known statuses.

Definition at line 1048 of file TradingClient.cpp.

{
    ListViewer::outputItems(orderBook_.getEntries(), print, 10);
}

traderLogon()

void traderLogon

(

)

Logs a trader into the connected BGW session.

Definition at line 588 of file TradingClient.cpp.

{
    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);
}

traderLogout()

void traderLogout

(

)

Logs the trader out from the BGW session.

Definition at line 605 of file TradingClient.cpp.

{
    checkConnected(bgwSession_, "BGW");
 
    MessageHolder<TraderLogoutRequest> request;
    request->originatorUserId(settings_.get("TraderId"));
 
    TradingClient::send(bgwSession_, request);
}