ListenerHolder.h

Go to the documentation of this file.

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

#include <OnixS/SgxTitan/MarketData/Itch/Compiler.h>
#include <OnixS/SgxTitan/MarketData/Itch/Defines.h>
#include <OnixS/SgxTitan/MarketData/Itch/ErrorListener.h>
#include <OnixS/SgxTitan/MarketData/Itch/HandlerStateListener.h>
#include <OnixS/SgxTitan/MarketData/Itch/Enumerations.h>
#include <OnixS/SgxTitan/MarketData/Itch/String.h>

#include <logging/LogFacility.h>

#include <OnixS/HandlerCore/Compiler.h>

#include "NamespaceHelper.h"

namespace OnixS {
namespace HandlerCore {
namespace Common {

class HandlerLogger;

}}}

ONIXS_HANDLER_NAMESPACE_BEGIN

struct SecondsMsg;
struct OrderBookDirectoryMsg;
struct CombinationOrderBookLegMsg;
struct TickSizeTableEntryMsg;
struct SystemEventMsg;
struct OrderBookStateMsg;
struct AddOrderMsg;
struct OrderExecutedMsg;
struct OrderExecutedWithPriceMsg;
struct OrderReplaceMsg;
struct OrderDeleteMsg;
struct TradeMsg;
struct EquilibriumPriceUpdateMsg;

class ErrorListener;
class WarningListener;
class HandlerStateListener;
class MessageListener;
class TimeListener;
class EventAndStateChangeListener;
class ReferenceDataListener;
class MarketByOrderListener;
class TradeListener;
class AuctionListener;
class OrderBookListener;
    
class OrderBookInternal;

class ListenerHolder : public Logging::LogFacility
{
    typedef OnixS::Logging::LogFacility base;

public:
    explicit
    ListenerHolder(const Logging::LogFacility* parent, HandlerCore::Common::HandlerLogger* logger = nullptr);

    void setLogger(HandlerCore::Common::HandlerLogger* handlerLogger);

    void set(ErrorListener* listener) { errorListener_ = listener; }
    void set(WarningListener* listener) { warningListener_ = listener; }
    void set(HandlerStateListener* listener) { handlerStateListener_ = listener; }
    void set(MessageListener* listener) { messageListener_ = listener; }
    void set(TimeListener* listener) { timeListener_ = listener; }
    void set(ReferenceDataListener* listener) { referenceDataListener_ = listener; }
    void set(EventAndStateChangeListener* listener) { systemEventListener_ = listener; }
    void set(MarketByOrderListener* listener) { orderListener_ = listener; }
    void set(TradeListener* listener) { tradeListener_ = listener; }
    void set(AuctionListener* listener) { auctionListener_ = listener; }
    void set(OrderBookListener* listener) { orderBookListener_ = listener; }


    bool hasOrderBookListener() const ONIXS_NOEXCEPT { return orderBookListener_ != nullptr; }
    bool hasErrorListener() const ONIXS_NOEXCEPT { return errorListener_ != nullptr; }
    bool hasWarningListener() const ONIXS_NOEXCEPT { return warningListener_ != nullptr; }
    bool hasHandlerStateListener() const ONIXS_NOEXCEPT { return handlerStateListener_ != nullptr; }
    bool hasMessageListener() const ONIXS_NOEXCEPT { return messageListener_ != nullptr; }
    bool hasTimeListener() const ONIXS_NOEXCEPT { return timeListener_ != nullptr; }
    bool hasReferenceDataListener() const ONIXS_NOEXCEPT { return referenceDataListener_ != nullptr; }
    bool hasSystemEventListener() const ONIXS_NOEXCEPT { return systemEventListener_ != nullptr; }
    bool hasMarketByOrderListener() const ONIXS_NOEXCEPT { return orderListener_ != nullptr; }
    bool hasTradeListener() const ONIXS_NOEXCEPT { return tradeListener_ != nullptr; }
    bool hasAuctionListener() const ONIXS_NOEXCEPT { return auctionListener_ != nullptr; }


    void invokeError(ErrorCode::Enum code, const std::string& description) ONIXS_NOEXCEPT;
    void invokeWarning(const std::string& description) ONIXS_NOEXCEPT;
    void invokeStateChanged(HandlerState::Enum newState) ONIXS_NOEXCEPT;

    void invokeGap(SequenceNumber expectedSeqNum, SequenceNumber receivedSeqNum) ONIXS_NOEXCEPT;
    void invokeInactivity() ONIXS_NOEXCEPT;

    void invokeTime(const SecondsMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT;

    void invokeOrderBookDirectory(const OrderBookDirectoryMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT;
    void invokeCombinationOrderBookLeg(const CombinationOrderBookLegMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT;
    void invokeTickSizeTableEntry(const TickSizeTableEntryMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT;

    void invokeSystemEvent(const SystemEventMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT;
    void invokeOrderBookState(const OrderBookStateMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT;

    void invokeAddOrder(const AddOrderMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT;
    void invokeOrderExecuted(const OrderExecutedMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT;
    void invokeOrderExecutedWithPrice(const OrderExecutedWithPriceMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT;
    void invokeOrderDelete(const OrderDeleteMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT;
    void invokeOrderReplace(const OrderReplaceMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT;

    void invokeTrade(const TradeMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT;
    void invokeEquilibriumPriceUpdate(const EquilibriumPriceUpdateMsg* msg, const DataSource& dataSource) ONIXS_NOEXCEPT;

    void invokeOrderBookUpdated(const OrderBookInternal& book) ONIXS_NOEXCEPT;
    void invokeOrderBookOutOfDate(const OrderBookInternal& book) ONIXS_NOEXCEPT;
    void invokeEndOfSession() ONIXS_NOEXCEPT;

    void invokeSnapshotRecoveryStarted() ONIXS_NOEXCEPT;
    void invokeSnapshotRecoveryFinished() ONIXS_NOEXCEPT;

private:
    void reportError(const std::string& description);

private:
    HandlerCore::Common::HandlerLogger* logger_;

    ErrorListener*               errorListener_;
    WarningListener*             warningListener_;
    HandlerStateListener*        handlerStateListener_;
    MessageListener*             messageListener_;

    TimeListener*                timeListener_;
    ReferenceDataListener*       referenceDataListener_;
    EventAndStateChangeListener* systemEventListener_;
    MarketByOrderListener*       orderListener_;
    TradeListener*               tradeListener_;
    AuctionListener*             auctionListener_;

    OrderBookListener*           orderBookListener_;
};

ONIXS_HANDLER_NAMESPACE_END