ListenerHolder.cpp

Go to the documentation of this file.

/*
* Copyright Onix Solutions Limited [OnixS]. All rights reserved.
*
* This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
* and international copyright treaties.
*
* Access to and use of the software is governed by the terms of the applicable OnixS Software
* Services Agreement (the Agreement) and Customer end user license agreements granting
* a non-assignable, non-transferable and non-exclusive license to use the software
* for it's own data processing purposes under the terms defined in the Agreement.
*
* Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
* of this source code or associated reference material to any other location for further reproduction
* or redistribution, and any amendments to this copyright notice, are expressly prohibited.
*
* Any reproduction or redistribution for sale or hiring of the Software not in accordance with
* the terms of the Agreement is a violation of copyright law.
*/

#include <boost/function.hpp>

#include "ListenerHolder.h"

#include <OnixS/SgxTitan/MarketData/Itch/ErrorListener.h>
#include <OnixS/SgxTitan/MarketData/Itch/WarningListener.h>
#include <OnixS/SgxTitan/MarketData/Itch/HandlerStateListener.h>

#include <OnixS/SgxTitan/MarketData/Itch/MessageListener.h>

#include <OnixS/SgxTitan/MarketData/Itch/MarketByOrderListener.h>
#include <OnixS/SgxTitan/MarketData/Itch/ReferenceDataListener.h>
#include <OnixS/SgxTitan/MarketData/Itch/EventAndStateChangeListener.h>
#include <OnixS/SgxTitan/MarketData/Itch/TimeListener.h>
#include <OnixS/SgxTitan/MarketData/Itch/TradeListener.h>
#include <OnixS/SgxTitan/MarketData/Itch/AuctionListener.h>

#include <OnixS/SgxTitan/MarketData/Itch/Messages.h>

#include <OnixS/SgxTitan/MarketData/Itch/OrderBookListener.h>

#include "HandlerLogger.h"
#include "BookImpl.h"

#include <boost/bind.hpp>

using namespace OnixS::HandlerCore::Common;

ONIXS_HANDLER_NAMESPACE_BEGIN

ListenerHolder::ListenerHolder (const OnixS::Logging::LogFacility* parent, HandlerLogger* logger)
    : base("ListenerHolder", parent, OnixS::Logging::LOG_LEVEL_DEBUG)
    , logger_(logger)
    , errorListener_(nullptr)
    , warningListener_(nullptr)
    , handlerStateListener_(nullptr)
    , messageListener_(nullptr)
    , timeListener_(nullptr)
    , referenceDataListener_(nullptr)
    , systemEventListener_(nullptr)
    , orderListener_(nullptr)
    , tradeListener_(nullptr)
    , auctionListener_(nullptr)
    , orderBookListener_(nullptr)
{
}

void ListenerHolder::setLogger (HandlerLogger* handlerLogger)
{
    BOOST_ASSERT(handlerLogger != nullptr);
    logger_ = handlerLogger;
}

/*
    User callback's
*/

void ListenerHolder::invokeError (
    ErrorCode::Enum code, const std::string& description) ONIXS_NOEXCEPT
{
    if (ErrorListener* listener = errorListener_)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(listener->onError(code, description), "onError");
    }
}

void ListenerHolder::invokeWarning (
    const std::string& description) ONIXS_NOEXCEPT
{
    if (WarningListener* listener = warningListener_)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(listener->onWarning(description), "onWarning");
    }
}

void ListenerHolder::invokeStateChanged (HandlerState::Enum newState) ONIXS_NOEXCEPT
{
    if (HandlerStateListener* listener = handlerStateListener_)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(listener->onStateChanged(newState), "onStateChanged");
    }
}

void ListenerHolder::invokeGap(
    SequenceNumber expectedSeqNum, SequenceNumber receivedSeqNum) ONIXS_NOEXCEPT
{
    if (messageListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(messageListener_->onGap(expectedSeqNum, receivedSeqNum), "onGap");
    }
}

void ListenerHolder::invokeInactivity() ONIXS_NOEXCEPT
{
    if (messageListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(messageListener_->onInactivity(), "onInactivity");
    }
}

void ListenerHolder::invokeTime(
    const SecondsMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT
{
    BOOST_ASSERT(msg != nullptr);

    if (timeListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(timeListener_->onSeconds(*msg, dataSource), "onSeconds");
    }
}

void ListenerHolder::invokeOrderBookDirectory(
    const OrderBookDirectoryMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT
{
    BOOST_ASSERT(msg != nullptr);

    if (referenceDataListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(referenceDataListener_->onOrderBookDirectory(*msg, dataSource), "onOrderBookDirectory");
    }
}

void ListenerHolder::invokeCombinationOrderBookLeg(
    const CombinationOrderBookLegMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT
{
    BOOST_ASSERT(msg != nullptr);

    if (referenceDataListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(referenceDataListener_->onCombinationOrderBookLeg(*msg, dataSource), "onCombinationOrderBookLeg");
    }
}

void ListenerHolder::invokeTickSizeTableEntry(
    const TickSizeTableEntryMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT
{
    BOOST_ASSERT(msg != nullptr);

    if (referenceDataListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(referenceDataListener_->onTickSizeTableEntry(*msg, dataSource), "onTickSizeTableEntry");
    }
}

void ListenerHolder::invokeSystemEvent(
    const SystemEventMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT
{
    BOOST_ASSERT(msg != nullptr);

    if (systemEventListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(systemEventListener_->onSystemEvent(*msg, dataSource), "onSystemEvent");
    }
}

void ListenerHolder::invokeOrderBookState(
    const OrderBookStateMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT
{
    BOOST_ASSERT(msg != nullptr);

    if (systemEventListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(systemEventListener_->onOrderBookState(*msg, dataSource), "onOrderBookState");
    }
}

void ListenerHolder::invokeAddOrder(
    const AddOrderMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT
{
    BOOST_ASSERT(msg != nullptr);

    if (orderListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(orderListener_->onAddOrder(*msg, dataSource), "onAddOrder");
    }
}

void ListenerHolder::invokeOrderExecuted(
    const OrderExecutedMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT
{
    BOOST_ASSERT(msg != nullptr);

    if (orderListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(orderListener_->onOrderExecuted(*msg, dataSource), "onOrderExecuted");
    }
}

void ListenerHolder::invokeOrderExecutedWithPrice(
    const OrderExecutedWithPriceMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT
{
    BOOST_ASSERT(msg != nullptr);

    if (orderListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(orderListener_->onOrderExecutedWithPrice(*msg, dataSource), "onOrderExecutedWithPrice");
    }
}

void ListenerHolder::invokeOrderReplace(
    const OrderReplaceMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT
{
    BOOST_ASSERT(msg != nullptr);

    if (orderListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(orderListener_->onOrderReplace(*msg, dataSource), "onOrderReplace");
    }
}

void ListenerHolder::invokeOrderDelete(
    const OrderDeleteMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT
{
    BOOST_ASSERT(msg != nullptr);

    if (orderListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(orderListener_->onOrderDelete(*msg, dataSource), "onOrderDelete");
    }
}

void ListenerHolder::invokeTrade(
    const TradeMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT
{
    BOOST_ASSERT(msg != nullptr);

    if (tradeListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(tradeListener_->onTrade(*msg, dataSource), "onTrade");
    }
}

void ListenerHolder::invokeEquilibriumPriceUpdate(
    const EquilibriumPriceUpdateMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT
{
    BOOST_ASSERT(msg != nullptr);

    if (tradeListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(auctionListener_->onEquilibriumPriceUpdate(*msg, dataSource), "onEquilibriumPriceUpdate");
    }
}

void ListenerHolder::invokeOrderBookUpdated(
    const OrderBookInternal& book) ONIXS_NOEXCEPT
{
    if (orderBookListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(orderBookListener_->onOrderBookUpdated(book), "onOrderBookUpdated");
    }
}

void ListenerHolder::invokeOrderBookOutOfDate(const OrderBookInternal& book) ONIXS_NOEXCEPT
{
    if (orderBookListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(orderBookListener_->onOrderBookOutOfDate(book), "onOrderBookOutOfDate");
    }
}

void ListenerHolder::invokeEndOfSession() ONIXS_NOEXCEPT
{
    if (messageListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(messageListener_->onEndOfSession(), "onEndOfSession");
    }
}

void ListenerHolder::invokeSnapshotRecoveryStarted() ONIXS_NOEXCEPT
{
    if (messageListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(messageListener_->onSnapshotRecoveryStarted(), "onSnapshotRecoveryStarted");
    }
}

void ListenerHolder::invokeSnapshotRecoveryFinished() ONIXS_NOEXCEPT
{
    if (messageListener_ != nullptr)
    {
        ONIXS_EXCEPTION_TRACED_CALLBACK(messageListener_->onSnapshotRecoveryFinished(), "onSnapshotRecoveryFinished");
    }
}

void ListenerHolder::reportError(const std::string& description)
{
    logger_->log(ONIXS_LOG_DEBUG[this] << description);
}

ONIXS_HANDLER_NAMESPACE_END