FeedSettings.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 <string>
 
#include <OnixS/CME/Streamlined/Integral.h>
 
ONIXS_CMESTREAMLINEDMDH_NAMESPACE_BEGIN

ONIXS_CMESTREAMLINEDMDH_LTWT_STRUCT RealtimeFeedLayout
{
    typedef UInt32 Base;
 
    enum Enum
    {
        FeedAOnly,

        FeedBOnly,

        FeedAWithFailoverToFeedB,

        FeedBWithFailoverToFeedA,

        BothFeedsWithArbitrage
    };
};

ONIXS_CMESTREAMLINEDMDH_EXPORTED
void
toStr(
    std::string&, 
    RealtimeFeedLayout::Enum);

inline 
std::string
toStr(
    RealtimeFeedLayout::Enum layout)
{
    std::string str;
    
    toStr(str, layout);
    
    return str;
}

ONIXS_CMESTREAMLINEDMDH_LTWT_CLASS RealtimeFeedSettings
{
    RealtimeFeedLayout::Enum layout_;
    UInt32 heartbeatInterval_;
    
    UInt32 outOfOrderPacketMaxInterval_;
    UInt32 lostPacketWaitTime_;
 
public:
    RealtimeFeedSettings()
        : layout_(
            RealtimeFeedLayout::
                BothFeedsWithArbitrage)
        , heartbeatInterval_(30)
        , outOfOrderPacketMaxInterval_(3)
        , lostPacketWaitTime_(100000)
    {
    }

    RealtimeFeedLayout::Enum layout() const
    {
        return layout_;
    }

    void layout(RealtimeFeedLayout::Enum value)
    {
        layout_ = value;
    }

    UInt32 heartbeatInterval() const
    {
        return heartbeatInterval_;
    }

    void heartbeatInterval(UInt32 value)
    {
        heartbeatInterval_ = value;
    }

    UInt32 outOfOrderPacketMaxInterval() const
    {
        return outOfOrderPacketMaxInterval_;
    }

    void outOfOrderPacketMaxInterval(UInt32 value)
    {
        outOfOrderPacketMaxInterval_ = value;
    }

    UInt32 lostPacketWaitTime() const
    {
        return lostPacketWaitTime_;
    }

    void lostPacketWaitTime(UInt32 value)
    {
        lostPacketWaitTime_ = value;
    }
};

ONIXS_CMESTREAMLINEDMDH_EXPORTED
void
toStr(
    std::string&, 
    const RealtimeFeedSettings&);

inline
std::string
toStr(
    const RealtimeFeedSettings& settings)
{
    std::string str;
 
    toStr(str, settings);
 
    return str;
}
 
// Parameters affecting all feeds involved into market data processing. 
ONIXS_CMESTREAMLINEDMDH_LTWT_CLASS FeedSettings
{
    std::string connectivityConfigurationFile_;
 
    std::string feedANetworkInterfaces_;
    std::string feedBNetworkInterfaces_;
 
    UInt16 maxPacketSize_;
 
    RealtimeFeedSettings incrementalFeeds_;
 
public:
    FeedSettings()
        : maxPacketSize_(1420)
    {
    }

    const 
    std::string& 
    connectivityConfigurationFile() const
    {
        return connectivityConfigurationFile_;
    }

    void 
    connectivityConfigurationFile(
        const std::string& configurationFile)
    {
        connectivityConfigurationFile_ = configurationFile;
    }

    const 
    std::string& 
    feedANetworkInterfaces() const
    {
        return feedANetworkInterfaces_;
    }

    void 
    feedANetworkInterfaces(
        const std::string& interfaces)
    {
        feedANetworkInterfaces_ = interfaces;
    }

    const 
    std::string& 
    feedBNetworkInterfaces() const
    {
        return feedBNetworkInterfaces_;
    }

    void 
    feedBNetworkInterfaces(
        const std::string& interfaces)
    {
        feedBNetworkInterfaces_ = interfaces;
    }

    UInt16 maxPacketSize() const
    {
        return maxPacketSize_;
    }

    void maxPacketSize(UInt16 value)
    {
        maxPacketSize_ = value;
    }

    const RealtimeFeedSettings& incrementalFeeds() const
    {
        return incrementalFeeds_;
    }

    RealtimeFeedSettings& incrementalFeeds()
    {
        return incrementalFeeds_;
    }
};

ONIXS_CMESTREAMLINEDMDH_EXPORTED
void
toStr(
    std::string&, 
    const FeedSettings&);

inline
std::string
toStr(
    const FeedSettings& settings)
{
    std::string str;
 
    toStr(str, settings);
 
    return str;
}
 
ONIXS_CMESTREAMLINEDMDH_NAMESPACE_END