Backtesting Sample

This sample demonstrates how to replay log files for the RDI, EMDI and EOBI feeds.

Source code

/*
* 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.
*/
#include <OnixS/Eurex/MarketData/RdiHandler.h>
#include <OnixS/Eurex/MarketData/EmdiHandler.h>
#include <OnixS/Eurex/MarketData/EobiHandler.h>
 
#include "RdiListener.h"
#include "EmdiListener.h"
#include "EobiListener.h"
 
#include "../Common/Options.h"
#include "../Common/Settings.h"
 
using namespace OnixS::Eurex::MarketData;
using namespace OnixS::Eurex::MarketData::EOBI;
 
class LogReplayConfiguration : public virtual Samples::ConfigurationBase
{
public:
    std::string rdiReplaySource() const
    {
        return argOrDefault(options(), "rdiReplaySource", "./logToReplay/rdi.log.bz2");
    }
 
    std::string emdiReplaySource() const
    {
        return argOrDefault(options(), "emdiReplaySource", "./logToReplay/emdi.log.bz2");
    }
 
    std::string eobiReplaySource() const
    {
        return argOrDefault(options(), "eobiReplaySource", "./logToReplay/eobi.log.bz2");
    }
 
protected:
    LogReplayConfiguration(size_t qty, char** args)
        : ConfigurationBase(qty, args)
    {
    }
 
    void showOptions(std::ostream& out) const override
    {
        out
            << "  --rdiReplaySource [filePath]" << std::endl
            << "\tDefault value is ['./logToReplay/rdi.log.bz2']" << std::endl
            << "  --emdiReplaySource [filePath]" << std::endl
            << "\tDefault value is ['./logToReplay/emdi.log.bz2']" << std::endl
            << "  --eobiReplaySource [filePath]" << std::endl
            << "\tDefault value is ['./logToReplay/eobi.log.bz2']" << std::endl
            ;
    }
};
 
template <typename Configuration>
void runRdiHandler(const Configuration& cfg)
{
    RdiListener listener;
 
    NoDelayReplay replayOptions;
    replayOptions.logs = {cfg.rdiReplaySource()};
    replayOptions.listener = &listener;
 
    RdiHandler handler(Samples::makeSettings<RdiHandlerSettings>(cfg));
    handler.registerErrorListener(&listener);
    handler.registerWarningListener(&listener);
    handler.registerReferenceDataListener(&listener);
 
    std::clog << "Will start the RDI Handler in replay log mode ..." << std::endl;
    handler.start(replayOptions);
 
    listener.waitUntilReplayFinished();
 
    std::clog << "RDI Handler Replay finished" << std::endl;
}
 
template <typename Configuration>
void runEmdiHandler(const Configuration& cfg)
{
    EmdiListener listener;
 
    NoDelayReplay replayOptions;
    replayOptions.logs = {cfg.emdiReplaySource()};
    replayOptions.listener = &listener;
 
    EmdiHandler handler(Samples::makeSettings<EmdiHandlerSettings>(cfg));
    listener.subscribe(handler);
 
    MarketSegmentId2Depth map;
    map[190] = 10;
 
    handler.setMarketSegmentId2Depth(map);
 
    handler.setPartitionIdFilters({3});
    handler.setMarketSegmentIdFilters({190});
 
    std::clog << "Will start the EMDI Handler in replay log mode ..." << std::endl;
    handler.start(replayOptions);
 
    listener.waitUntilReplayFinished();
 
    std::clog << "EMDI Handler Replay finished" << std::endl;
}
 
template <typename Configuration>
void runEobiHandler(const Configuration& cfg)
{
    EobiListener listener;
 
    NoDelayReplay replayOptions;
    replayOptions.logs = {cfg.eobiReplaySource()};
    replayOptions.listener = &listener;
 
    auto settings = Samples::makeSettings<EobiHandlerSettings>(cfg);
    settings.bookDepth = 10;
 
    EobiHandler handler(settings);
    listener.subscribe(handler);
 
    std::clog << "Will start the EOBI Handler in replay log mode ..." << std::endl;
    handler.start(replayOptions);
 
    listener.waitUntilReplayFinished();
    std::clog << "EOBI Handler Replay finished" << std::endl;
}

int main(int argc, char* argv[])
{
    // `--help` to show options.
    const Samples::AppConfiguration<Samples::LogDirectoryConfiguration, LogReplayConfiguration> cfg{"Backtesting", argc, argv};
 
    try
    {
        runRdiHandler(cfg);
        runEmdiHandler(cfg);
        runEobiHandler(cfg);
    }
    catch(const std::exception& ex)
    {
        std::cerr << "EXCEPTION: " << ex.what() << std::endl;
    }
 
    return 0;
}

#pragma once
/*
* 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.
*/
#include <iostream>
 
#include <OnixS/Eurex/MarketData/ErrorListener.h>
#include <OnixS/Eurex/MarketData/WarningListener.h>
#include <OnixS/Eurex/MarketData/Replay.h>
#include <OnixS/Eurex/MarketData/ReferenceDataListener.h>
#include <OnixS/Eurex/MarketData/Semaphore.h>
 
 
class RdiListener final
    : public OnixS::Eurex::MarketData::ErrorListener
    , public OnixS::Eurex::MarketData::WarningListener
    , public OnixS::Eurex::MarketData::ReplayListener
    , public OnixS::Eurex::MarketData::ReferenceDataListener
{
public:
    RdiListener();

    ~RdiListener() override;

    void onError(OnixS::Eurex::MarketData::ErrorCode::Enum code, const std::string& description) override;

    void onWarning(const std::string& description) override;
 
    void onReplayError(const std::string& errorDescription) override
    {
        std::clog << "Replay error: " << errorDescription << std::endl;
        replaySemaphore_.release();
    }
 
    void onReplayFinished() override
    {
        replaySemaphore_.release();
    }

    void waitUntilReplayFinished()
    {
        replaySemaphore_.acquire();
    }

    void onSnapshotCycleStart() override;

    void onProduct(const OnixS::Eurex::MarketData::ProductSnapshot& productSnapshot, const OnixS::Eurex::MarketData::DataSource& dataSource) override;

    void onInstrument(const OnixS::Eurex::MarketData::InstrumentSnapshot& msg, const OnixS::Eurex::MarketData::DataSource& dataSource) override;

    void onInstrumentIncremental(const OnixS::Eurex::MarketData::InstrumentIncremental& msg, const OnixS::Eurex::MarketData::DataSource& dataSource) override;

    void onVarianceFuturesStatus(const OnixS::Eurex::MarketData::VarianceFuturesStatus& msg, const OnixS::Eurex::MarketData::DataSource& dataSource) override;

    void onTotalReturnFuturesStatus(const OnixS::Eurex::MarketData::TotalReturnFuturesStatus& msg, const OnixS::Eurex::MarketData::DataSource& dataSource) override;

    void onTradeAtReferencePriceStatus(const OnixS::Eurex::MarketData::TradeAtReferencePriceStatus& msg, const OnixS::Eurex::MarketData::DataSource& dataSource) override;

    void onSnapshotCycleEnd() override;
 
private:
    OnixS::Eurex::MarketData::Semaphore replaySemaphore_;
};

/*
* 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.
*/
#include <sstream>
 
#include "RdiListener.h"
 
using namespace OnixS::Eurex::MarketData;
 
/*
    RdiListener
*/
 
RdiListener::RdiListener()
    : replaySemaphore_(0)
{
}
 
RdiListener::~RdiListener() = default;
 
void RdiListener::onError(ErrorCode::Enum code, const std::string& description)
{
    std::clog << "Error occurred, errorCode = " << enumToString(code) << ". Description: '" << description << "'" << std::endl;
}
 
void RdiListener::onWarning(const std::string& description)
{
    std::stringstream ss;
    std::clog << "Warning occurred. Description: '" << description << "'" << std::endl;
}
 
void RdiListener::onSnapshotCycleStart()
{
}
 
void RdiListener::onProduct(const ProductSnapshot& msg, const DataSource&)
{
    std::clog << "Message received: " << msg.toString('|') << std::endl;
}
 
void RdiListener::onInstrument(const InstrumentSnapshot&, const DataSource&)
{
}
 
void RdiListener::onInstrumentIncremental(const InstrumentIncremental&, const DataSource&)
{
}
 
void RdiListener::onVarianceFuturesStatus(const VarianceFuturesStatus&, const DataSource&)
{
}
 
void RdiListener::onTotalReturnFuturesStatus(const TotalReturnFuturesStatus&, const DataSource&)
{
}
 
void RdiListener::onTradeAtReferencePriceStatus(const TradeAtReferencePriceStatus&, const DataSource&)
{
}
 
void RdiListener::onSnapshotCycleEnd()
{
    replaySemaphore_.release();
}

/*
* 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 <iostream>
#include <sstream>
 
#include <OnixS/Eurex/MarketData/ErrorListener.h>
#include <OnixS/Eurex/MarketData/WarningListener.h>
#include <OnixS/Eurex/MarketData/Replay.h>
#include <OnixS/Eurex/MarketData/DepthListener.h>
#include <OnixS/Eurex/MarketData/TopOfBookImpliedListener.h>
#include <OnixS/Eurex/MarketData/ProductStateChangeListener.h>
#include <OnixS/Eurex/MarketData/MassInstrumentStateChangeListener.h>
#include <OnixS/Eurex/MarketData/InstrumentStateChangeListener.h>
#include <OnixS/Eurex/MarketData/QuoteRequestListener.h>
#include <OnixS/Eurex/MarketData/CrossRequestListener.h>
#include <OnixS/Eurex/MarketData/ComplexInstrumentUpdateListener.h>
#include <OnixS/Eurex/MarketData/FlexibleInstrumentUpdateListener.h>
#include <OnixS/Eurex/MarketData/OrderBookListener.h>
#include <OnixS/Eurex/MarketData/TradeListener.h>
#include <OnixS/Eurex/MarketData/Semaphore.h>
#include <OnixS/Eurex/MarketData/EmdiHandler.h>
 
class EmdiListener final
    : public OnixS::Eurex::MarketData::ErrorListener
    , public OnixS::Eurex::MarketData::WarningListener
    , public OnixS::Eurex::MarketData::ReplayListener
    , public OnixS::Eurex::MarketData::DepthListener
    , public OnixS::Eurex::MarketData::TopOfBookImpliedListener
    , public OnixS::Eurex::MarketData::ProductStateChangeListener
    , public OnixS::Eurex::MarketData::MassInstrumentStateChangeListener
    , public OnixS::Eurex::MarketData::InstrumentStateChangeListener
    , public OnixS::Eurex::MarketData::QuoteRequestListener
    , public OnixS::Eurex::MarketData::CrossRequestListener
    , public OnixS::Eurex::MarketData::ComplexInstrumentUpdateListener
    , public OnixS::Eurex::MarketData::FlexibleInstrumentUpdateListener
    , public OnixS::Eurex::MarketData::OrderBookListener
    , public OnixS::Eurex::MarketData::TradeListener
{
public:
    EmdiListener();

    ~EmdiListener() override;
 
    void subscribe(OnixS::Eurex::MarketData::EmdiHandler& handler);

    void onError(OnixS::Eurex::MarketData::ErrorCode::Enum code, const std::string& description) override;

    void onWarning(const std::string& description) override;
 
    void onReplayError(const std::string& errorDescription) override
    {
        std::clog << "Replay error: " << errorDescription << std::endl;
        replaySemaphore_.release();
    }
 
    void onReplayFinished() override
    {
        replaySemaphore_.release();
    }

    void waitUntilReplayFinished()
    {
        replaySemaphore_.acquire();
    }
 
    void onDepthSnapshot(const OnixS::Eurex::MarketData::DepthSnapshot& snapshot, const OnixS::Eurex::MarketData::DataSource& dataSource) override;

    void onDepthIncremental(const OnixS::Eurex::MarketData::DepthIncremental& incremental, const OnixS::Eurex::MarketData::DataSource& dataSource) override;

    void onDepthReset(OnixS::Eurex::MarketData::MarketSegmentId marketSegmentId) override;

    void onDepthOutOfDate(OnixS::Eurex::MarketData::MarketSegmentId marketSegmentId) override;

    void onTopOfBookImplied(const  OnixS::Eurex::MarketData::TopOfBookImplied& msg, const  OnixS::Eurex::MarketData::DataSource& dataSource) override;

    void onProductStateChange(const OnixS::Eurex::MarketData::ProductStateChange& change, const OnixS::Eurex::MarketData::DataSource& dataSource) override;

    void onMassInstrumentStateChange(const OnixS::Eurex::MarketData::MassInstrumentStateChange& change, const OnixS::Eurex::MarketData::DataSource& dataSource) override;

    void onInstrumentStateChange(const OnixS::Eurex::MarketData::InstrumentStateChange& change, const OnixS::Eurex::MarketData::DataSource& dataSource) override;

    void onQuoteRequest(const OnixS::Eurex::MarketData::QuoteRequest& request, const OnixS::Eurex::MarketData::DataSource& dataSource) override;

    void onCrossRequest(const OnixS::Eurex::MarketData::CrossRequest& request, const OnixS::Eurex::MarketData::DataSource& dataSource) override;

    void onComplexInstrumentUpdate(const OnixS::Eurex::MarketData::ComplexInstrumentUpdate& update, const OnixS::Eurex::MarketData::DataSource& dataSource) override;

    void onFlexibleInstrumentUpdate(const OnixS::Eurex::MarketData::FlexibleInstrumentUpdate& update, const OnixS::Eurex::MarketData::DataSource& dataSource) override;

    void onOrderBookUpdated(const OnixS::Eurex::MarketData::OrderBook& book) override;

    void onOrderBookOutOfDate(const OnixS::Eurex::MarketData::OrderBook& book) override;

    void onSnapshotTrade(const OnixS::Eurex::MarketData::SnapshotTrade& trade) override;

    void onIncrementalTrade(const OnixS::Eurex::MarketData::IncrementalTrade& trade) override;
 
private:
    OnixS::Eurex::MarketData::Semaphore replaySemaphore_;
};

/*
* 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.
*/
#include "EmdiListener.h"
 
using namespace OnixS::Eurex::MarketData;
 
/*
    EmdiListener
*/
 
EmdiListener::EmdiListener()
    : replaySemaphore_(0)
{
}
 
void EmdiListener::subscribe(OnixS::Eurex::MarketData::EmdiHandler& handler)
{
    handler.registerErrorListener(this);
    handler.registerWarningListener(this);
    handler.registerDepthListener(this);
    handler.registerTopOfBookImpliedListener(this);
    handler.registerProductStateChangeListener(this);
    handler.registerMassInstrumentStateChangeListener(this);
    handler.registerInstrumentStateChangeListener(this);
    handler.registerQuoteRequestListener(this);
    handler.registerCrossRequestListener(this);
    handler.registerComplexInstrumentUpdateListener(this);
    handler.registerFlexibleInstrumentUpdateListener(this);
    handler.registerOrderBookListener(this);
    handler.registerTradeListener(this);
}
 
EmdiListener::~EmdiListener() = default;
 
void EmdiListener::onError(ErrorCode::Enum code, const std::string& description)
{
    std::clog << "Error occurred, errorCode = " << enumToString(code) << ". Description: '" << description << "'" << std::endl;
}
 
void EmdiListener::onWarning(const std::string& description)
{
    std::stringstream ss;
    std::clog << "Warning occurred. Description: '" << description << "'" << std::endl;
}
 
void EmdiListener::onDepthSnapshot(const DepthSnapshot& msg, const DataSource&)
{
    std::clog << "Message received: " << msg.toString('|') << std::endl;
}
 
void EmdiListener::onDepthIncremental(const DepthIncremental& msg, const DataSource&)
{
    std::clog << "Message received: " << msg.toString('|') << std::endl;
}
 
void EmdiListener::onDepthReset(MarketSegmentId)
{
}
 
void EmdiListener::onDepthOutOfDate(MarketSegmentId)
{
}
 
void EmdiListener::onTopOfBookImplied(const TopOfBookImplied&, const DataSource&)
{
}
 
void EmdiListener::onProductStateChange(const ProductStateChange&, const DataSource&)
{
}
 
void EmdiListener::onMassInstrumentStateChange(const MassInstrumentStateChange&, const DataSource&)
{
}
 
void EmdiListener::onInstrumentStateChange(const InstrumentStateChange&, const DataSource&)
{
}
 
void EmdiListener::onQuoteRequest(const QuoteRequest&, const DataSource&)
{
}
 
void EmdiListener::onCrossRequest(const CrossRequest&, const DataSource&)
{
}
 
void EmdiListener::onComplexInstrumentUpdate(const ComplexInstrumentUpdate&, const DataSource&)
{
}
 
void EmdiListener::onFlexibleInstrumentUpdate(const FlexibleInstrumentUpdate&, const DataSource&)
{
}
 
void EmdiListener::onOrderBookUpdated(const OrderBook&)
{
}
 
void EmdiListener::onOrderBookOutOfDate(const OrderBook&)
{
}
 
void EmdiListener::onSnapshotTrade(const SnapshotTrade&)
{
}
 
void EmdiListener::onIncrementalTrade(const IncrementalTrade&)
{
}

/*
* 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/Eurex/MarketData/Compiler.h>
#include <OnixS/Eurex/MarketData/ErrorListener.h>
#include <OnixS/Eurex/MarketData/WarningListener.h>
#include <OnixS/Eurex/MarketData/Replay.h>
#include <OnixS/Eurex/MarketData/Semaphore.h>
#include <OnixS/Eurex/MarketData/HandlerStateListener.h>
#include <OnixS/Eurex/MarketData/EOBI/Listeners.h>
#include <OnixS/Eurex/MarketData/EobiHandler.h>
 
 
class EobiListener final
    : public OnixS::Eurex::MarketData::ErrorListener
    , public OnixS::Eurex::MarketData::WarningListener
    , public OnixS::Eurex::MarketData::ReplayListener
    , public OnixS::Eurex::MarketData::HandlerStateListener
    , public OnixS::Eurex::MarketData::EOBI::OrderDataListener
    , public OnixS::Eurex::MarketData::EOBI::TradeDataListener
    , public OnixS::Eurex::MarketData::EOBI::StateChangeListener
    , public OnixS::Eurex::MarketData::EOBI::ReferenceDataListener
    , public OnixS::Eurex::MarketData::EOBI::SnapshotListener
    , public OnixS::Eurex::MarketData::EOBI::MessageListener
    , public OnixS::Eurex::MarketData::EOBI::OrderBookListener
{
public:
    EobiListener();

    ~EobiListener() override;

    void subscribe(OnixS::Eurex::MarketData::EOBI::EobiHandler& handler);

    void onError(OnixS::Eurex::MarketData::ErrorCode::Enum code, const std::string& description) override;

    void onWarning(const std::string& description) override;
 
    void onReplayError(const std::string& errorDescription) override;
 
    void onReplayFinished() override;

    void waitUntilReplayFinished();
 
    void onStateChanged(OnixS::Eurex::MarketData::HandlerState::Enum newState) override;
 
    void onOrderAdd(const OnixS::Eurex::MarketData::EOBI::OrderAdd& orderAdd) override;
 
    void onOrderModify(const OnixS::Eurex::MarketData::EOBI::OrderModify& orderModify) override;
 
    void onOrderModifySamePriority(const OnixS::Eurex::MarketData::EOBI::OrderModifySamePriority& orderModify) override;
 
    void onOrderDelete(const OnixS::Eurex::MarketData::EOBI::OrderDelete& orderDelete) override;
 
    void onOrderMassDelete(const OnixS::Eurex::MarketData::EOBI::OrderMassDelete& orderMassDelete) override;
 
    void onPartialOrderExecution(const OnixS::Eurex::MarketData::EOBI::PartialOrderExecution& partialOrderExecution) override;
 
    void onFullOrderExecution(const OnixS::Eurex::MarketData::EOBI::FullOrderExecution& fullOrderExecution) override;
 
    void onAuctionBestBidOffer(const OnixS::Eurex::MarketData::EOBI::AuctionBestBidOffer& auctionBestBidOffer) override;
 
    void onAuctionClearingPrice(const OnixS::Eurex::MarketData::EOBI::AuctionClearingPrice& auctionClearingPrice) override;
 
    void onTopOfBook(const OnixS::Eurex::MarketData::EOBI::TopOfBook& topOfBook) override;
 
    void onExecutionSummary(const OnixS::Eurex::MarketData::EOBI::ExecutionSummary& executionSummary) override;
 
    void onQuoteRequest(const OnixS::Eurex::MarketData::EOBI::QuoteRequest& quoteRequest) override;
 
    void onCrossRequest(const OnixS::Eurex::MarketData::EOBI::CrossRequest& crossRequest) override;
 
    void onTradeReport(const OnixS::Eurex::MarketData::EOBI::TradeReport& tradeReport) override;
 
    void onTESTradeReport(const OnixS::Eurex::MarketData::EOBI::TESTradeReport& tradeReport) override;
 
    void onTradeReversal(const OnixS::Eurex::MarketData::EOBI::TradeReversal& tradeReversal) override;
 
    void onProductStateChange(const OnixS::Eurex::MarketData::EOBI::ProductStateChange& productStateChange) override;
 
    void onInstrumentStateChange(const OnixS::Eurex::MarketData::EOBI::InstrumentStateChange& instrumentStateChange) override;
 
    void onMassInstrumentStateChange(const OnixS::Eurex::MarketData::EOBI::MassInstrumentStateChange& instrumentStateChange) override;
 
    void onAddComplexInstrument(const OnixS::Eurex::MarketData::EOBI::AddComplexInstrument& addComplexInstrument) override;
 
    void onAddScaledSimpleInstrument(const OnixS::Eurex::MarketData::EOBI::AddScaledSimpleInstrument& addScaledSimpleInstrument) override;
 
    void onAddFlexibleInstrument(const OnixS::Eurex::MarketData::EOBI::AddFlexibleInstrument& addFlexibleInstrument) override;
 
    void onProductSummary(const OnixS::Eurex::MarketData::EOBI::ProductSummary& productSummary) override;
 
    void onInstrumentSummary(const OnixS::Eurex::MarketData::EOBI::InstrumentSummary& instrumentSummary) override;
 
    void onSnapshotOrder(const OnixS::Eurex::MarketData::EOBI::SnapshotOrder& snapshotOrder) override;
 
    void onMarketSegmentReset(OnixS::Eurex::MarketData::MarketSegmentId marketSegmentId) override;
 
    void onMarketSegmentOutOfDate(OnixS::Eurex::MarketData::MarketSegmentId marketSegmentId) override;
 
    void onOrderBookUpdated(const OnixS::Eurex::MarketData::EOBI::OrderBook& book) override;
 
    void onOrderBookOutOfDate(const OnixS::Eurex::MarketData::EOBI::OrderBook& book) override;
 
    void onSnapshotCycleBegin() override;
 
    void onSnapshotCycleEnd() override;
 
private:
    OnixS::Eurex::MarketData::Semaphore replaySemaphore_;
};

/*
* 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.
*/
#include <iostream>
#include <sstream>
 
#include <OnixS/Eurex/MarketData/EOBI/Messages.h>
 
#include "EobiListener.h"
 
using namespace OnixS::Eurex::MarketData;
using namespace OnixS::Eurex::MarketData::EOBI;
 
/*
    EobiListener
*/
 
EobiListener::EobiListener()
    : replaySemaphore_(0)
{
}
 
void EobiListener::subscribe(OnixS::Eurex::MarketData::EOBI::EobiHandler& handler)
{
    handler.registerErrorListener(this);
    handler.registerWarningListener(this);
    handler.registerHandlerStateListener(this);
    handler.registerOrderDataListener(this);
    handler.registerTradeDataListener(this);
    handler.registerStateChangeListener(this);
    handler.registerReferenceDataListener(this);
    handler.registerSnapshotListener(this);
    handler.registerMessageListener(this);
    handler.registerOrderBookListener(this);
}
 
EobiListener::~EobiListener() = default;
 
void EobiListener::onError(ErrorCode::Enum code, const std::string& description)
{
    std::clog << "Error occurred, errorCode = " << enumToString(code) << ". Description: '" << description << "'" << std::endl;
}
 
void EobiListener::onWarning(const std::string& description)
{
    std::stringstream ss;
    std::clog << "Warning occurred. Description: '" << description << "'" << std::endl;
}
 
void EobiListener::onReplayError(const std::string& errorDescription)
{
    std::clog << "Replay error: " << errorDescription << std::endl;
    replaySemaphore_.release();
}
 
void EobiListener::onReplayFinished()
{
    replaySemaphore_.release();
}

void EobiListener::waitUntilReplayFinished()
{
    replaySemaphore_.acquire();
}
 
void EobiListener::onStateChanged(HandlerState::Enum newState)
{
    std::clog << "Handler state changed: " << enumToString(newState) << std::endl;
}
 
std::string toString(const MessageBase& msg)
{
    return msg.toString();
}
 
void EobiListener::onOrderAdd(const OrderAdd& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onOrderModify(const OrderModify& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onOrderModifySamePriority(const OrderModifySamePriority& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onOrderDelete(const OrderDelete& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onOrderMassDelete(const OrderMassDelete& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onPartialOrderExecution(const PartialOrderExecution& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onFullOrderExecution(const FullOrderExecution& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onAuctionBestBidOffer(const AuctionBestBidOffer& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onAuctionClearingPrice(const AuctionClearingPrice& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onTopOfBook(const TopOfBook& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onExecutionSummary(const ExecutionSummary& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onQuoteRequest(const EOBI::QuoteRequest& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onCrossRequest(const EOBI::CrossRequest& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onTradeReport(const TradeReport& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onTESTradeReport(const OnixS::Eurex::MarketData::EOBI::TESTradeReport& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onTradeReversal(const TradeReversal& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onProductStateChange(const EOBI::ProductStateChange& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onInstrumentStateChange(const EOBI::InstrumentStateChange& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onMassInstrumentStateChange(
    const OnixS::Eurex::MarketData::EOBI::MassInstrumentStateChange& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onAddComplexInstrument(const AddComplexInstrument& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onAddScaledSimpleInstrument(const AddScaledSimpleInstrument& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onAddFlexibleInstrument(const AddFlexibleInstrument& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onProductSummary(const ProductSummary& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onInstrumentSummary(const InstrumentSummary& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onSnapshotOrder(const SnapshotOrder& msg)
{
    std::clog << "Message received: " << toString(msg) << std::endl;
}
 
void EobiListener::onMarketSegmentReset(MarketSegmentId)
{
}
 
void EobiListener::onMarketSegmentOutOfDate(MarketSegmentId)
{
}
 
void EobiListener::onOrderBookUpdated(const EOBI::OrderBook&)
{
}
 
void EobiListener::onOrderBookOutOfDate(const EOBI::OrderBook&)
{
}
 
void EobiListener::onSnapshotCycleBegin()
{
}
 
void EobiListener::onSnapshotCycleEnd()
{
}