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

#include <string>

namespace OnixS { namespace Senaf { namespace MarketData {

/// \brief The Handler for BME SENAF trading system events.
///
/// The `Handler` class is responsible for connecting to the BME SENAF Financial Asset
/// Electronic Trading System, processing exchange events, and notifying user code through
/// callbacks. It ensures efficient handling of market data, logging, and listener
/// registration, providing a robust interface for interacting with the exchange's data feed.
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();

    /// Retrieves the expiration date of the Handler's license.
    ///
    /// This method returns a string representing the date when the Handler's license
    /// will expire. The expiration date is provided in the format "YYYYMMDD", where:
    ///
    /// - YYYY represents the four-digit year,
    /// - MM represents the two-digit month,
    /// - DD represents the two-digit day.
    ///
    /// This information is useful for ensuring that the Handler's license remains valid
    /// and for tracking when renewal is required.
    ///
    /// \returns A string containing the license expiration date in "YYYYMMDD" format.
    std::string licenseExpirationDate() const;

    /// \brief Retrieves the version of the Handler.
    ///
    /// This method returns a constant reference to a string representing the version
    /// of the Handler in the format "X.Y.Z". The version information is useful for
    /// tracking the Handler's release or update state in the system.
    ///
    /// \returns A constant reference to a string containing the version of the Handler.
    static const std::string& version();

    /// Logs a debug message for diagnostic purposes.
    ///
    /// This method records a debug-level message to the logging system,
    /// which can be useful for tracking application behavior and troubleshooting.
    /// It is safe to call this method from any thread.
    ///
    /// \param message The debug message to be logged.
    void logDebug(const std::string& message);

    /// Logs an error message to the logging system.
    ///
    /// This method records an error-level message, which can be critical for
    /// monitoring application health and diagnosing issues. It is safe to call
    /// this method from any thread.
    ///
    /// \param message The error message to be logged, providing context for the issue.
    void logError(const std::string& message);

    /// Logs an informational message to the logging system.
    ///
    /// This method records an informational-level message, which can be useful for
    /// general application logging and monitoring. It is safe to call this method
    /// from any thread.
    ///
    /// \param message The informational message to be logged.
    void logMessage(const std::string& message);

    /// Logs a warning message to the logging system.
    ///
    /// This method records a warning-level message, which can be useful for
    /// highlighting potential issues or unusual conditions in the application.
    /// It is safe to call this method from any thread.
    ///
    /// \param message The warning message to be logged.
    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);

    /// Subscribes to market data updates based on the provided subscription details.
    ///
    /// This method registers the specified market subscription, allowing the Handler
    /// to receive updates related to the market events specified in the subscription.
    /// It is safe to call this method from any thread.
    ///
    /// \param subscription The details of the market subscription to be registered.
    void subscribe(const MarketSubscription& subscription);

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

    /// Stops the Handler.
    void stop();

    /// Retrieves the current state of the Handler.
    ///
    /// This method is safe for concurrent access across multiple threads.
    ///
    /// \returns The current state of the Handler that indicates the Handler's operational status.
    HandlerStates::Enum state() const;

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

private:
    class Implementation;
    Implementation* impl_;
};

}}} // namespace OnixS::Senaf::MarketData