Getting Started Sample

This sample shows how to connect to B3 UMDF channel.

Source code

#include <iostream>

#include <Common/Configuring.h>
#include <Common/Options.h>
#include <Common/Utils.h>

#include <OnixS/B3/MarketData/UMDF.h>

#include "MyListener.h"

using namespace std;
using namespace OnixS::B3::MarketData::UMDF;
using Sample::MyListener;

/// Wait until the user presses the button
void waitUntilEnterKey ()
{
    std::string tmp;
    std::getline (std::cin, tmp);
}

// Handles sample input parameters.
class Configuration
    : public ChannelConfiguration
    , public ConnectivityConfiguration
    , public FeedConfiguration
{
public:
    Configuration(size_t qty, Char** args)
        : ConfigurationBase(qty, args)
        , ChannelConfiguration(qty, args, 80)
        , ConnectivityConfiguration(qty, args)
        , FeedConfiguration(qty, args)
    {
    }

private:
    void showOptions(std::ostream& out) const ONIXS_B3_UMDF_MD_OVERRIDE
    {
        ChannelConfiguration::showOptions(out);
        ConnectivityConfiguration::showOptions(out);
        FeedConfiguration::showOptions(out);
    }
};

/// The main entry point.
int main (int qty, char** args)
{
    clog << "OnixS C++ B3 Binary UMDF Market Data Handler Getting Started sample, version " << Handler::version() << '.' << endl << endl;

    const Configuration configuration(qty, args);

    if (configuration.show())
    {
        configuration.show(std::cout);
        return 0;
    }

    checkNetworkSettings(configuration);

    HandlerSettings handlerSettings;

    handlerSettings.licenseDirectory                           = "../../license";
    handlerSettings.loggerSettings.logDirectory                = "logs";
    handlerSettings.loggerSettings.logLevel                    = LogLevel::Debug;
    handlerSettings.buildOrderBooks = true;

    handlerSettings.loadFeeds(configuration.channel(), configuration.connectivityFile());

    handlerSettings.networkInterfaceA = configuration.ifA();
    handlerSettings.networkInterfaceB = configuration.ifB();

    try
    {
        MyListener myListener;

        Handler handler(handlerSettings);

        handler.registerWarningListener(&myListener);
        handler.registerErrorListener (&myListener);
        handler.registerMessageListener (&myListener);

        clog << "Will start the Handler ..." << endl;

        try
        {
            handler.start();
        }
        catch (const std::exception& ex)
        {
            clog << "Unable to start the handler: " << ex.what() << endl;
        }
        catch (...)
        {
            clog << "Unable to start the handler" << endl;
        }

        clog << "Please press Enter key to stop the handler..." << endl;

        waitUntilEnterKey ();

        clog << "Stopping..." << endl;

        handler.stop (true);

        clog << "The Handler has been stopped." << endl;
    }
    catch (const Exception& ex)
    {
        cerr << "EXCEPTION: " << ex.what() << endl;
    }
    catch (const std::exception& ex)
    {
        cerr << "EXCEPTION: " << ex.what() << endl;
    }
    catch (...)
    {
        cerr << "UNKNOWN EXCEPTION" << endl;
    }

    clog << "Press Enter key to close application..." << endl;

    waitUntilEnterKey();

    return 0;
}

MyListener.h:

#include <fstream>

#include <OnixS/B3/MarketData/UMDF/ErrorListener.h>
#include <OnixS/B3/MarketData/UMDF/Messaging.h>
#include <OnixS/B3/MarketData/UMDF/MessageListener.h>
#include <OnixS/B3/MarketData/UMDF/WarningListener.h>

namespace Sample
{
    using namespace std;
    using namespace OnixS::B3::MarketData::UMDF;

    class MyListener :
        public MessageListener,
        public WarningListener,
        public ErrorListener
    {
        public:
            /// Constructor
            MyListener();

            /// Inherited from Warning Listener
            /// Is called when the Warning condition is detected
            void onWarning (const std::string& reason)
            ONIXS_B3_UMDF_MD_FINAL;

            /// Inherited from Error Listener
            /// Notifications about errors
            void onError (ErrorCode::Enum code, const std::string& description)
            ONIXS_B3_UMDF_MD_FINAL;

            void onSequenceReset_1(const Messaging::SequenceReset_1, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onSequence_2(const Messaging::Sequence_2, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onEmptyBook_9(const Messaging::EmptyBook_9, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onChannelReset_11(const Messaging::ChannelReset_11, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onSecurityStatus_3(const Messaging::SecurityStatus_3, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onSecurityGroupPhase_10(const Messaging::SecurityGroupPhase_10, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onSecurityDefinition_12(const Messaging::SecurityDefinition_12, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;

            void onSnapshotFullRefresh_Header_30(const Messaging::SnapshotFullRefresh_Header_30, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onSnapshotFullRefresh_Orders_MBO_71(const Messaging::SnapshotFullRefresh_Orders_MBO_71, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;

            void onNews_5(const Messaging::News_5, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onClosingPrice_17(const Messaging::ClosingPrice_17, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onQuantityBand_21(const Messaging::QuantityBand_21, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onPriceBand_22(const Messaging::PriceBand_22, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;

            void onOpeningPrice_15(const Messaging::OpeningPrice_15, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onTheoreticalOpeningPrice_16(const Messaging::TheoreticalOpeningPrice_16, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onAuctionImbalance_19(const Messaging::AuctionImbalance_19, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onHighPrice_24(const Messaging::HighPrice_24, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onLowPrice_25(const Messaging::LowPrice_25, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onLastTradePrice_27(const Messaging::LastTradePrice_27, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onSettlementPrice_28(const Messaging::SettlementPrice_28, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onOpenInterest_29(const Messaging::OpenInterest_29, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onOrder_MBO_50(const Messaging::Order_MBO_50, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onDeleteOrder_MBO_51(const Messaging::DeleteOrder_MBO_51, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onMassDeleteOrders_MBO_52(const Messaging::MassDeleteOrders_MBO_52, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onTrade_53(const Messaging::Trade_53, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onForwardTrade_54(const Messaging::ForwardTrade_54, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onExecutionSummary_55(const Messaging::ExecutionSummary_55, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onExecutionStatistics_56(const Messaging::ExecutionStatistics_56, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;
            void onTradeBust_57(const Messaging::TradeBust_57, const DataSource&) ONIXS_B3_UMDF_MD_FINAL;

        private:
            ofstream marketDataLog_;
    };

}

MyListener.cpp:

#include <iostream>

#include "MyListener.h"

namespace Sample
{
    MyListener::MyListener()
    {
        const std::string marketDataLogName = "logs/MarketData.txt";
        marketDataLog_.open (marketDataLogName.c_str() );

        if (!marketDataLog_)
            throw domain_error ("Cannot open " + marketDataLogName);
    }

    void MyListener::onWarning (const std::string& reason)
    {
        clog << "Warning occurred. Description: '" << reason << "'" << endl;
    }

    void MyListener::onError (ErrorCode::Enum code, const std::string& description)
    {
        clog << "Error occurred, errorCode = " << enumToString (code) << ". Description: '" << description << "'" << endl;
    }

    void MyListener::onSequenceReset_1(const Messaging::SequenceReset_1 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onSequence_2(const Messaging::Sequence_2 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onEmptyBook_9(const Messaging::EmptyBook_9 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onChannelReset_11(const Messaging::ChannelReset_11 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onSecurityStatus_3(const Messaging::SecurityStatus_3 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onSecurityGroupPhase_10(const Messaging::SecurityGroupPhase_10 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onSecurityDefinition_12(const Messaging::SecurityDefinition_12 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }


    void MyListener::onSnapshotFullRefresh_Header_30(const Messaging::SnapshotFullRefresh_Header_30 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onSnapshotFullRefresh_Orders_MBO_71(const Messaging::SnapshotFullRefresh_Orders_MBO_71 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }


    void MyListener::onNews_5(const Messaging::News_5 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onClosingPrice_17(const Messaging::ClosingPrice_17 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onQuantityBand_21(const Messaging::QuantityBand_21 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onPriceBand_22(const Messaging::PriceBand_22 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }


    void MyListener::onOpeningPrice_15(const Messaging::OpeningPrice_15 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onTheoreticalOpeningPrice_16(const Messaging::TheoreticalOpeningPrice_16 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onAuctionImbalance_19(const Messaging::AuctionImbalance_19 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onHighPrice_24(const Messaging::HighPrice_24 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onLowPrice_25(const Messaging::LowPrice_25 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onLastTradePrice_27(const Messaging::LastTradePrice_27 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onSettlementPrice_28(const Messaging::SettlementPrice_28 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onOpenInterest_29(const Messaging::OpenInterest_29 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onOrder_MBO_50(const Messaging::Order_MBO_50 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onDeleteOrder_MBO_51(const Messaging::DeleteOrder_MBO_51 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onMassDeleteOrders_MBO_52(const Messaging::MassDeleteOrders_MBO_52 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onTrade_53(const Messaging::Trade_53 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onForwardTrade_54(const Messaging::ForwardTrade_54 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onExecutionSummary_55(const Messaging::ExecutionSummary_55 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onExecutionStatistics_56(const Messaging::ExecutionStatistics_56 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }

    void MyListener::onTradeBust_57(const Messaging::TradeBust_57 msg, const DataSource&)
    {
        marketDataLog_ << msg << endl;
    }
}