Deserialization Sample

Reads a single binary ICE iMpact message from a file, dispatches on its message type and prints the decoded message. It illustrates how to deserialize raw market data messages without running a live Handler.

Source code

#include "../Common/Utils.h"
 
#include <OnixS/ICE/iMpact/MarketData/Messages.h>
 
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <stdexcept>
#include <vector>
 
using namespace OnixS::ICE::iMpact::MarketData;
 
inline unsigned short rotate(unsigned short x)
{
    return (x >> 8) | ((x & 0xff) << 8);
}
 
template <typename T>
void dump(const std::vector<char>& data)
{
    std::cout << T(&data[0], data.size()) << std::endl;
}
 
int main(int argc, char** argv)
{
    try
    {
        introduceMyself("Deserialization");
 
        const std::string HELP_ARG = "--help";
 
        if (argc == 2 && HELP_ARG == argv[1])
        {
            std::cout << "Usage: Deserialization <path>" << std::endl;
            return EXIT_SUCCESS;
        }
 
        const char* path = argc > 1 ? argv[1] : "data/FuturesProductDefinition.bin";
 
        std::ifstream ifs(path);
 
        if (!ifs)
        {
            std::cerr << "ERROR: can't open file '" << path << "'" << std::endl;
            return EXIT_FAILURE;
        }
 
        char msgType = 0;
        ifs.read(&msgType, sizeof(msgType));
 
        unsigned short msgSize = 0;
        ifs.read((char*)&msgSize, sizeof(msgSize));
        msgSize = rotate(msgSize);
 
        const std::size_t fullMsgSize = sizeof(msgType) + sizeof(msgSize) + msgSize;
        std::vector<char> data(fullMsgSize);
        ifs.read(&data[3], msgSize);
 
        switch (msgType)
        {
        case AddModifyOrder::messageType:
            dump<AddModifyOrder>(data);
            break;
        case AddPriceLevel::messageType:
            dump<AddPriceLevel>(data);
            break;
        case BundleMarker::messageType:
            dump<BundleMarker>(data);
            break;
        case CancelledTrade::messageType:
            dump<CancelledTrade>(data);
            break;
        case ChangePriceLevel::messageType:
            dump<ChangePriceLevel>(data);
            break;
        case ClosePrice::messageType:
            dump<ClosePrice>(data);
            break;
        case DeleteOrder::messageType:
            dump<DeleteOrder>(data);
            break;
        case DeletePriceLevel::messageType:
            dump<DeletePriceLevel>(data);
            break;
        case EndOfDayMarketSummary::messageType:
            dump<EndOfDayMarketSummary>(data);
            break;
        case FixingIndicativePrice::messageType:
            dump<FixingIndicativePrice>(data);
            break;
        case FixingLockdown::messageType:
            dump<FixingLockdown>(data);
            break;
        case FixingTransition::messageType:
            dump<FixingTransition>(data);
            break;
        case FuturesProductDefinition::messageType:
            dump<FuturesProductDefinition>(data);
            break;
        case FuturesStrategyDefinition::messageType:
            dump<FuturesStrategyDefinition>(data);
            break;
        case IntervalTieredPriceLimitNotification::messageType:
            dump<IntervalTieredPriceLimitNotification>(data);
            break;
        case InvestigatedTrade::messageType:
            dump<InvestigatedTrade>(data);
            break;
        case MarkerIndexPrices::messageType:
            dump<MarkerIndexPrices>(data);
            break;
        case MarketEvent::messageType:
            dump<MarketEvent>(data);
            break;
        case MarketSnapshot::messageType:
            dump<MarketSnapshot>(data);
            break;
        case MarketSnapshotOrder::messageType:
            dump<MarketSnapshotOrder>(data);
            break;
        case MarketSnapshotPriceLevel::messageType:
            dump<MarketSnapshotPriceLevel>(data);
            break;
        case MarketStateChange::messageType:
            dump<MarketStateChange>(data);
            break;
        case MarketStatistics::messageType:
            dump<MarketStatistics>(data);
            break;
        case NewExpiry::messageType:
            dump<NewExpiry>(data);
            break;
        case NewFuturesStrategyDefinition::messageType:
            dump<NewFuturesStrategyDefinition>(data);
            break;
        case NewOptionsMarketDefinition::messageType:
            dump<NewOptionsMarketDefinition>(data);
            break;
        case NewOptionsStrategyDefinition::messageType:
            dump<NewOptionsStrategyDefinition>(data);
            break;
        case OldStyleOptionsTradeAndMarketStats::messageType:
            dump<OldStyleOptionsTradeAndMarketStats>(data);
            break;
        case OpenInterest::messageType:
            dump<OpenInterest>(data);
            break;
        case OpenPrice::messageType:
            dump<OpenPrice>(data);
            break;
        case OptionsProductDefinition::messageType:
            dump<OptionsProductDefinition>(data);
            break;
        case OptionsStrategyDefinition::messageType:
            dump<OptionsStrategyDefinition>(data);
            break;
        case OptionOpenInterest::messageType:
            dump<OptionOpenInterest>(data);
            break;
        case OptionSettlementPrice::messageType:
            dump<OptionSettlementPrice>(data);
            break;
        case PreOpenPriceIndicator::messageType:
            dump<PreOpenPriceIndicator>(data);
            break;
        case Rfq::messageType:
            dump<Rfq>(data);
            break;
        case SettlementPrice::messageType:
            dump<SettlementPrice>(data);
            break;
        case SpecialField::messageType:
            dump<SpecialField>(data);
            break;
        case SpotMarketTrade::messageType:
            dump<SpotMarketTrade>(data);
            break;
        case SystemText::messageType:
            dump<SystemText>(data);
            break;
        case Trade::messageType:
            dump<Trade>(data);
            break;
        default:
            std::cout << "ERROR: unknown message type '" << msgType << "'" << std::endl;
            break;
        }
    }
    catch (const std::exception& ex)
    {
        std::cerr << "Error: " << ex.what() << std::endl;
        return EXIT_FAILURE;
    }
    catch (...)
    {
        std::cerr << "Unknown exception." << std::endl;
        return EXIT_FAILURE;
    }
 
    return EXIT_SUCCESS;
}