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 <OnixS/Senaf/MarketData/Export.h>
#include <OnixS/Senaf/MarketData/ErrorListener.h>
#include <OnixS/Senaf/MarketData/HandlerSettings.h>
#include <OnixS/Senaf/MarketData/HandlerStateChangeListener.h>
#include <OnixS/Senaf/MarketData/LogReplayListener.h>
#include <OnixS/Senaf/MarketData/ReferenceListener.h>
#include <OnixS/Senaf/MarketData/SecurityDbListener.h>
#include <OnixS/Senaf/MarketData/MarketControlListener.h>
#include <OnixS/Senaf/MarketData/MarketPublicationListener.h>
#include <OnixS/Senaf/MarketData/MarketSubscription.h>
#include <OnixS/Senaf/MarketData/OrderBookUpdateListener.h>
#include <OnixS/Senaf/MarketData/PrivateManagementListener.h>
#include <OnixS/Senaf/MarketData/WarningListener.h>

#include <string>

namespace OnixS { namespace Senaf { namespace MarketData {

/// Senaf market data processor
class ONIXS_BME_SENAF_EXPORT Handler
{
public:
    /// Performs instance initialization.
    ///
    /// \param handlerSettings defines values for various settings
    /// which affect handler behavior like enabling logging
    /// during execution of the handler.
    Handler(const HandlerSettings& handlerSettings);

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

    /// Date when license for the Handler will expire.
    std::string licenseExpirationDate() const;

    /// Get version of Handler.
    static const std::string& version();

    /// Log a debug message.
    void logDebug(const std::string& message);

    /// Log an error message.
    void logError(const std::string& message);

    /// Log an information message.
    void logMessage(const std::string& message);

    /// Log a warning message.
    void logWarning(const std::string& message);

    /// Registers the error listener.
    ///
    /// Only single instance of listener can be associated with
    /// the Handler. Registering new listener removes previous one.
    ///
    /// Listeners are to be associated before starting market data
    /// processing.
    ///
    /// \throw exception in case of Handler is in active state.
    void registerErrorListener(ErrorListener* listener);

    /// Registers the warning listener.
    ///
    /// Only single instance of listener can be associated with
    /// the Handler. Registering new listener removes previous one.
    ///
    /// Listeners are to be associated before starting market data
    /// processing.
    ///
    /// \throw exception in case of Handler is in active state.
    void registerWarningListener(WarningListener* listener);

    /// Registers the Handler state change listener.
    ///
    /// Only single instance of listener can be associated with
    /// the Handler. Registering new listener removes previous one.
    ///
    /// Listeners are to be associated before starting market data
    /// processing.
    ///
    /// \throw exception in case of Handler is in active state.
    void registerHandlerStateChangeListener(HandlerStateChangeListener* listener);

    /// Registers the log replay listener.
    ///
    /// Only single instance of listener can be associated with
    /// the Handler. Registering new listener removes previous one.
    ///
    /// Listeners are to be associated before starting market data
    /// processing.
    ///
    /// \throw exception in case of Handler is in active state.
    void registerLogReplayListener(LogReplayListener* listener);

    /// Registers the Reference listener.
    ///
    /// Only single instance of listener can be associated with
    /// the Handler. Registering new listener removes previous one.
    ///
    /// Listeners are to be associated before starting market data
    /// processing.
    ///
    /// \throw exception in case of Handler is in active state.
    void registerReferenceListener(ReferenceListener* listener);

    /// Registers the Security DB listener.
    ///
    /// Only single instance of listener can be associated with
    /// the Handler. Registering new listener removes previous one.
    ///
    /// Listeners are to be associated before starting market data
    /// processing.
    ///
    /// \throw exception in case of Handler is in active state.
    void registerSecurityDbListener(SecurityDbListener* listener);

    /// Registers the Market Publication Messages listener.
    ///
    /// Only single instance of listener can be associated with
    /// the Handler. Registering new listener removes previous one.
    ///
    /// Listeners are to be associated before starting market data
    /// processing.
    ///
    /// \throw exception in case of Handler is in active state.
    void registerMarketPublicationListener(MarketPublicationListener* listener);

    /// Registers the Market Control Messages listener.
    ///
    /// Only single instance of listener can be associated with
    /// the Handler. Registering new listener removes previous one.
    ///
    /// Listeners are to be associated before starting market data
    /// processing.
    ///
    /// \throw exception in case of Handler is in active state.
    void registerMarketControlListener(MarketControlListener* listener);

    /// Registers the order book update listener.
    ///
    /// Only single instance of listener can be associated with
    /// the Handler. Registering new listener removes previous one.
    ///
    /// Listeners are to be associated before starting market data
    /// processing.
    ///
    /// \throw exception in case of Handler is in active state.
    void registerOrderBookUpdateListener(OrderBookUpdateListener* listener);

    /// Registers the Private Management Messages listener.
    ///
    /// Only single instance of listener can be associated with
    /// the Handler. Registering new listener removes previous one.
    ///
    /// Listeners are to be associated before starting market data
    /// processing.
    ///
    /// \throw exception in case of Handler is in active state.
    void registerPrivateManagementListener(PrivateManagementListener* listener);

    /// Subscribe on market
    void subscribe(const MarketSubscription& subscription);

    /// Starts handler
    ///
    /// \throw exception in case of unable to establish TCP connection.
    void start();

    /// Stops handler
    void stop();

    /// Get handler state.
    HandlerStates::Enum state() const;

private:
    Handler(const Handler&) /*= delete */;                  // no implementation
    Handler& operator=(const Handler&) /*= delete */;       // no implementation

private:
    class Implementation;
    Implementation* impl_;
};

}}}                                                        // namespace MarketData, Senaf, OnixS