Handler.h

Go to the documentation of this file.

/*
 * Copyright (c) Onix Solutions Limited. All rights reserved.
 *
 * This software owned by Onix Solutions Limited 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 "ErrorListener.h"
#include "ExchangeListener.h"
#include "Export.h"
#include "FeedEngine.h"
#include "FeedListener.h"
#include "GroupSubscription.h"
#include "HandlerSettings.h"
#include "HandlerStateChangeListener.h"
#include "LogReplayListener.h"
#include "MarketSubscription.h"
#include "OrderBookBundleUpdateListener.h"
#include "OrderBookChangeListener.h"
#include "OrderBookUpdateListener.h"
#include "PacketProcessingListener.h"
#include "TcpSettings.h"
#include "WarningListener.h"
 
#include <string>
 
namespace OnixS { namespace ICE { namespace iMpact { namespace MarketData {

class ONIXS_ICEMDH_EXPORT Handler
{
public:
    Handler(const HandlerSettings& handlerSettings);

    virtual ~Handler();

    std::string licenseExpirationDate() const;

    static const std::string& version();

    void logDebug(const std::string& message);

    void logError(const std::string& message);

    void logMessage(const std::string& message);

    void logWarning(const std::string& message);

    void registerOrderBookChangeListener(OrderBookChangeListener* listener);

    void registerOrderBookUpdateListener(OrderBookUpdateListener* listener);

    void registerOrderBookBundleUpdateListener(OrderBookBundleUpdateListener* listener);

    void registerErrorListener(ErrorListener* listener);

    void registerWarningListener(WarningListener* listener);

    void registerExchangeListener(ExchangeListener* listener);

    void registerFeedListener(FeedListener* listener);

    void registerHandlerStateChangeListener(HandlerStateChangeListener* listener);

    void registerLogReplayListener(LogReplayListener* listener);

    void registerPacketProcessingListener(PacketProcessingListener* listener);

    void bindFeedEngine(FeedEngine& feedEngine);

    void start(const MarketSubscription& marketSubscription);

    void start(const MarketSubscriptions& marketSubscriptions);

    void start(const GroupSubscription& groupSubscription);

    void start(const GroupSubscriptions& groupSubscriptions);

    void stop();

    bool active() const;

    HandlerStates::Enum state() const;

    void setTcpSettings(const TcpSettings& tcpSettings);

    const TcpSettings& getTcpSettings() const;

    void setTcpServerCredentials(const std::string& name, const std::string& username, const std::string& password);
 
private:
    Handler(const Handler&) /*= delete */;            // no implementation
    Handler& operator=(const Handler&) /*= delete */; // no implementation
 
private:
    class Implementation;
    Implementation* impl_;
};
 
}}}} // namespace OnixS::ICE::iMpact::MarketData