Handler.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 <string>
#include <memory>

#include <OnixS/CME/ConflatedUDP/Bootstrap.h>

ONIXS_CONFLATEDUDP_NAMESPACE_BEGIN

ONIXS_CONFLATEDUDP_LTWT_CLASS_DECL(HandlerSettings);
ONIXS_CONFLATEDUDP_LTWT_CLASS_DECL(MemoryPoolSettings);
ONIXS_CONFLATEDUDP_LTWT_CLASS_DECL(InstrumentSelection);

#if !defined (ONIXS_CONFLATEDUDP_NO_DEPRECATED)

ONIXS_CONFLATEDUDP_EXPORTED_STRUCT_DECL(HandlerListener);
ONIXS_CONFLATEDUDP_EXPORTED_STRUCT_DECL(ChannelFeedListener);

ONIXS_CONFLATEDUDP_EXPORTED_STRUCT_DECL(MarketDataListener);
ONIXS_CONFLATEDUDP_EXPORTED_STRUCT_DECL(SecurityListener);

ONIXS_CONFLATEDUDP_EXPORTED_CLASS_DECL(Logger);
ONIXS_CONFLATEDUDP_EXPORTED_CLASS_DECL(NetFeedEngine);
ONIXS_CONFLATEDUDP_EXPORTED_CLASS_DECL(TcpRecoveryService);

ONIXS_CONFLATEDUDP_LTWT_CLASS_DECL(SessionSettings);
ONIXS_CONFLATEDUDP_LTWT_CLASS_DECL(ReplaySettings);

#endif // ONIXS_CONFLATEDUDP_NO_DEPRECATED

ONIXS_CONFLATEDUDP_INTERNAL_CLASS_DECL(ChannelModel);

/// Encapsulates all the machinery related with market 
/// data processing from CME Market Data Platform.
ONIXS_CONFLATEDUDP_EXPORTED_CLASS Handler
{
    // Data processing workhorse. 
    ChannelModel* model_;

    // Coping is not allowed for the instances. 

    Handler(const Handler&);
    Handler& operator =(const Handler&);

public:
    /// Initializes the instance with the default settings.
    Handler();

    /// Initializes instance with the memory pool 
    /// configured according to the given settings. 
    Handler(
        const 
        MemoryPoolSettings&);

#if !defined (ONIXS_CONFLATEDUDP_NO_DEPRECATED)

    /// Initializes the instance 
    /// according to the given settings. 
    /// 
    /// @warning The given member is deprecated.
    /// The Handler configuration can be updated
    /// any time through the settings() member when 
    /// the Handler does not process market data. 
    Handler(
        const HandlerSettings&);

#endif // ONIXS_CONFLATEDUDP_NO_DEPRECATED

    /// Finalizes the instance.
    ~Handler();

    /// The configuration parameters of the given instance. 
    HandlerSettings& settings();

    /// Immutable configuration of the given instance. 
    const HandlerSettings& settings() const;

#if !defined (ONIXS_CONFLATEDUDP_NO_DEPRECATED)

    /// Logger currently used by the Handler. 
    /// 
    /// @warning The given member is deprecated.
    /// Use settings().logging().logger() member
    /// to access the Logger instance used by the 
    /// Handler while logging its events. 
    Logger& logger();

#endif // ONIXS_CONFLATEDUDP_NO_DEPRECATED

    /// Filters instruments whose market data 
    /// is to be processed and events are to be 
    /// fired by the Handler.
    ///
    /// @warning Instrument selection can be 
    /// updated only when market data processing 
    /// is not performed by the Handler or upon 
    /// successful instrument recovery completion. 
    void 
    selectInstruments(
        const InstrumentSelection&);

    /// Erases instrument definitions cache if used. 
    /// Handler will produce a new cache at next start.
    void clearInstrumentCache();

#if !defined (ONIXS_CONFLATEDUDP_NO_DEPRECATED)

    /// Registers Handler events listener.
    ///
    /// Only single instance of listener can be 
    /// associated with the Handler. Registering 
    /// new listener removes previous one. Listener 
    /// instance lifetime shall be not less than 
    /// Handler's one.
    ///
    /// Listeners are to be associated before 
    /// starting market data processing - Handler 
    /// must be in stopped state.
    ///
    /// @throw std::exception in case when 
    /// handler is not in configurable state.
    /// 
    /// @warning The given member is deprecated.
    /// Use settings().listeners().handler() member
    /// to assign the listener for the desired events. 
    void
    registerListener(
        HandlerListener& listener);

    /// Registers feed event listener.
    ///
    /// Only single instance of listener can be 
    /// associated with the Handler. Registering 
    /// new listener removes previous one. Listener 
    /// instance lifetime shall be not less than 
    /// Handler's one.
    ///
    /// Listeners are to be associated before 
    /// starting market data processing - Handler 
    /// must be in stopped state.
    ///
    /// @throw std::exception in case when 
    /// handler is not in configurable state.
    /// 
    /// @warning The given member is deprecated.
    /// Use settings().listeners().feeds() member
    /// to assign the listener for the desired events. 
    void
    registerFeedListener(
        ChannelFeedListener& listener);

    /// Registers market data processing listener.
    ///
    /// Only single instance of listener can be 
    /// associated with the Handler. Registering 
    /// new listener removes previous one. Listener 
    /// instance lifetime shall be not less than 
    /// Handler's one.
    ///
    /// Listeners are to be associated before 
    /// starting market data processing - Handler 
    /// must be in stopped state.
    ///
    /// @throw std::exception in case when 
    /// handler is not in configurable state.
    /// 
    /// @warning The given member is deprecated.
    /// Use settings().listeners().marketData() member
    /// to assign the listener for the desired events. 
    void
    registerMarketDataListener(
        MarketDataListener& listener);

    /// Registers security events listener.
    ///
    /// Only single instance of listener can be 
    /// associated with the Handler. Registering 
    /// new listener removes previous one. Listener 
    /// instance lifetime shall be not less than 
    /// Handler's one.
    ///
    /// Listeners are to be associated before 
    /// starting market data processing - Handler 
    /// must be in stopped state.
    ///
    /// @throw std::exception in case when 
    /// handler is not in configurable state.
    /// 
    /// @warning The given member is deprecated.
    /// Use settings().listeners().security() member
    /// to assign the listener for the desired events. 
    void
    registerSecurityListener(
        SecurityListener& listener);

    /// Binds Feed Engine to the Handler.
    ///
    /// Handler must be in stopped state.
    ///
    /// @throw std::exception in case when 
    /// handler is not in configurable state.
    /// 
    /// @warning The given member is deprecated.
    /// Use settings().feeds().engine() member to 
    /// assign the feed engine used by the Handler
    /// while manipulating the feeds. 
    void
    bindFeedEngine(
        NetFeedEngine& feedEngine);

    /// Binds TCP Recovery Service to the Handler.
    ///
    /// Handler must be in stopped state.
    ///
    /// @throw std::exception in case when 
    /// handler is not in configurable state.
    /// 
    /// @warning The given member is deprecated.
    /// Use settings().session().tcpRecovery().service() 
    /// member to assign the TCP recovery service used by 
    /// the Handler to request missing packets. 
    void
    bindTcpRecovery(
        TcpRecoveryService& tcpRecovery);

    /// Binds Logging Service to the Handler.
    ///
    /// Handler must be in stopped state.
    ///
    /// @throw std::exception in case when 
    /// handler is not in configurable state.
    /// 
    /// @warning The given member is deprecated.
    /// Use settings().logging().logger() member 
    /// to assign the Logger instance used by the 
    /// Handler to log various events. 
    void 
    bindLogger(
        Logger& logger);

#endif // ONIXS_CONFLATEDUDP_NO_DEPRECATED

    /// Starts market data processing. 
    void start();

#if !defined (ONIXS_CONFLATEDUDP_NO_DEPRECATED)

    /// Updates the session configuration 
    /// according to the given settings and 
    /// starts market data processing. 
    /// 
    /// @warning The given member is deprecated.
    /// Use settings().session() member to update 
    /// session-related configuration and start() 
    /// member to launch market data processing. 
    void 
    start(
        const SessionSettings&);

#endif // ONIXS_CONFLATEDUDP_NO_DEPRECATED

    /// Stops market data processing. 
    void stop();
};

ONIXS_CONFLATEDUDP_NAMESPACE_END