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/ConflatedUDP/Integral.h>
#include <OnixS/CME/ConflatedUDP/PacketTraits.h>
#include <OnixS/CME/ConflatedUDP/SettingGroup.h>

ONIXS_CONFLATEDUDP_NAMESPACE_BEGIN

// A bit of forward declarations.

ONIXS_CONFLATEDUDP_EXPORTED_CLASS_DECL
(
    NetFeedEngine
);

/// Collection of parameters which 
/// are common for all types of feeds.
template
<
    typename Layout
>
class 
FeedSettingsBase
{
    const SettingGroup& group_;

    Layout layout_;
    UInt32 heartbeatInterval_;

    std::string feedANetworkInterfaces_;
    std::string feedBNetworkInterfaces_;

    FeedSettingsBase&
    operator =(
        const 
        FeedSettingsBase& other);

protected:
    // Makes assignment more flexible. 
    friend
    ONIXS_CONFLATEDUDP_LTWT_CLASS_DECL
    (
        FeedSettings
    );

    /// Initializes the instance with the 
    /// given values and optional grouping.
    FeedSettingsBase(
        const SettingGroup* group, 
        Layout layout, UInt32 heartbeat)
        : group_(
            group
            ? *group
            : SettingGroup::null())
        , layout_(layout)
        , heartbeatInterval_(heartbeat)
    {
    }

    /// Initializes the instance 
    /// as a copy of the other one. 
    /// 
    /// Attributes controlling value 
    /// assignment aren't cloned and 
    /// thus only settings are copied. 
    FeedSettingsBase(
        const 
        FeedSettingsBase& other)
        : group_(
            SettingGroup::null())
        , layout_(
            other.layout_)
        , heartbeatInterval_(
            other.heartbeatInterval_)
        , feedANetworkInterfaces_(
            other.feedANetworkInterfaces_)
        , feedBNetworkInterfaces_(
            other.feedBNetworkInterfaces_)
    {
    }

    // Finalizes the instance. 
    ~FeedSettingsBase()
    {
    }

    /// Instance of the group which 
    /// the given settings belong to. 
    const 
    SettingGroup& 
    group() const
    {
        return group_;
    }

    /// Re-initializes the instance as a 
    /// copy of the other one without involving 
    /// assignment control services. 
    void
    assignNoControl(
        const FeedSettingsBase& other)
    {
        layout_ = 
            other.layout_;

        heartbeatInterval_ = 
            other.heartbeatInterval_;

        feedANetworkInterfaces_ =
            other.feedANetworkInterfaces_;

        feedBNetworkInterfaces_ = 
            other.feedBNetworkInterfaces_;
    }

public:
    /// Defines feed layout for a feed group.
    Layout layout() const
    {
        return layout_;
    }

    /// Defines feed layout for recovery feed group.
    void 
    layout(
        Layout value)
    {
        group_.
            controlAssignment
            (
                "Layout",
                layout_, 
                value
            );
    }

    /// Specifies maximal time interval between two
    /// network packets. If no data is received during
    /// specified time frame, corresponding event is raised 
    /// and further behavior is defined by feed layout. 
    ///
    /// Interval is measured in seconds. 
    UInt32 
    heartbeatInterval() const
    {
        return heartbeatInterval_;
    }

    /// Specifies maximal time interval between two packets. 
    void 
    heartbeatInterval(
        UInt32 interval)
    {
        group_.
            controlAssignment
            (
                "Heartbeat Interval",
                heartbeatInterval_, 
                interval
            );
    }

    /// Specifies one or more network interfaces to use for 
    /// "A" feeds while joining the multicast group; use 
    /// semi-colon delimited list if more than one.
    /// 
    /// @note On Linux the network interface is specified 
    /// by its name, on Windows - by IP address.
    /// 
    /// @note If the value is empty or absent then the 
    /// Settings::networkInterface value is used.
    const 
    std::string& 
    feedANetworkInterfaces() const
    {
        return feedANetworkInterfaces_;
    }

    /// Specifies one or more network interfaces to use for 
    /// "A" feeds while joining the multicast group; use 
    /// semi-colon delimited list if more than one.
    void 
    feedANetworkInterfaces(
        const std::string& interfaces)
    {
        group_.
            controlAssignment
            (
                "Feed A Network Interfaces",
                feedANetworkInterfaces_, 
                interfaces
            );
    }

    /// Specifies one or more network interfaces to use for "B"
    /// feeds while joining the multicast group; use semi-colon
    /// delimited list if more than one.
    ///
    /// @note On Linux the network interface is specified by
    /// its name, on Windows - by IP address.
    ///
    /// @note If the value is empty or absent then the
    /// Settings::networkInterface value is used.
    const 
    std::string& 
    feedBNetworkInterfaces() const
    {
        return feedBNetworkInterfaces_;
    }

    /// Specifies one or more network interfaces to use for 
    /// "B" feeds while joining the multicast group; use 
    /// semi-colon delimited list if more than one.
    void 
    feedBNetworkInterfaces(
        const std::string& interfaces)
    {
        group_.
            controlAssignment
            (
                "Feed B Network Interfaces",
                feedBNetworkInterfaces_, 
                interfaces
            );
    }
};

/// Defines feed layout alternates available for 
/// recovery feeds like instrument and snapshot. 
ONIXS_CONFLATEDUDP_LTWT_STRUCT RecoveryFeedLayout
{
    /// Integral type used as basement for constants. 
    typedef UInt32 Base;

    enum Enum
    {
        /// Indicates only feed A is used as source for market data. 
        FeedAOnly,

        /// Indicates only feed B is used as source for market data. 
        FeedBOnly,

        /// Feed A is used as primary source of market data. If Handler
        /// detects absence of market data on feed A, it switches to 
        /// feed B to continue market data processing. Feed B is used 
        /// by Handler until market data absence is detected on it. In 
        /// that case Handler will switch back to feed A. In other words,
        /// this layout instructs Handler to cycle between feeds if data
        /// absence is detected starting from feed A.
        FeedAWithFailoverToFeedB,

        /// Feed B is used as primary source of market data. If Handler
        /// detects absence of market data on feed B, it switches to 
        /// feed A to continue market data processing. Feed A is used 
        /// by Handler until market data absence is detected on it. In 
        /// that case Handler will switch back to feed B. In other words,
        /// this layout instructs Handler to cycle between feeds if data
        /// absence is detected starting from feed B.
        FeedBWithFailoverToFeedA
    };
};

/// Appends string presentation of feed layout.
ONIXS_CONFLATEDUDP_EXPORTED
void
toStr(
    std::string&, 
    RecoveryFeedLayout::Enum);

/// Returns string presentation of feed layout.
inline 
std::string
toStr(
    RecoveryFeedLayout::Enum layout)
{
    std::string str;
    
    toStr(str, layout);
    
    return str;
}

/// Collection of parameters affecting recovery feeds behavior. 
ONIXS_CONFLATEDUDP_LTWT_CLASS
MulticastRecoveryFeedSettings
: public FeedSettingsBase
  <
    RecoveryFeedLayout::Enum
  >
{
    friend
    ONIXS_CONFLATEDUDP_LTWT_CLASS_DECL
    (
        FeedSettings
    );

    typedef 
    FeedSettingsBase
    <
        RecoveryFeedLayout::Enum
    >
    Base;

    void
    assignNoControl(
        const 
        MulticastRecoveryFeedSettings& other)
    {
        Base::assignNoControl(other);
    }

public:
    /// Initializes instance with default values. 
    /// 
    /// By default, feed A is used as the primary source 
    /// of market recovery data with fail-over to the feed B. 
    /// Heartbeats are expected within 30 seconds periodicity.
    MulticastRecoveryFeedSettings(
        const SettingGroup* group = NULL)
    : Base(
        group, 
        RecoveryFeedLayout::
        FeedAWithFailoverToFeedB,
        30)
    {
    }

    /// Initializes the instance as a copy of the other one. 
    MulticastRecoveryFeedSettings(
        const MulticastRecoveryFeedSettings& other)
        : Base(static_cast<const Base&>(other))
    {
    }

    /// Finalizes the instance.
    ~MulticastRecoveryFeedSettings()
    {
    }

    /// Re-initializes the instance as a copy of the other one. 
    MulticastRecoveryFeedSettings&
    operator =(
        const 
        MulticastRecoveryFeedSettings& other)
    {
        group().
            controlAssignment
            (
                "Multicast Recovery Feed Settings",
                &MulticastRecoveryFeedSettings::assignNoControl,
                *this,
                other
            );

        return *this;
    }
};

/// Serializes feed settings into string.
ONIXS_CONFLATEDUDP_EXPORTED
void
toStr(
    std::string&, 
    const MulticastRecoveryFeedSettings&);

/// Serializes feed settings into string.
inline
std::string
toStr(
    const 
    MulticastRecoveryFeedSettings& settings)
{
    std::string str;

    toStr(str, settings);

    return str;
}

/// Collection of parameters affecting recovery feeds behavior. 
ONIXS_CONFLATEDUDP_LTWT_CLASS
TcpRecoveryFeedSettings
: public FeedSettingsBase
  <
    RecoveryFeedLayout::Enum
  >
{
    // Makes assignment more flexible. 
    friend
    ONIXS_CONFLATEDUDP_LTWT_CLASS_DECL
    (
        FeedSettings
    );

    typedef 
    FeedSettingsBase
    <
        RecoveryFeedLayout::Enum
    >
    Base;

    UInt32 connectionAttempts_;
    UInt32 connectionTimeout_;
    UInt32 sendTimeout_;

    void
    assignNoControl(
        const TcpRecoveryFeedSettings& other)
    {
        Base::assignNoControl(other);

        connectionAttempts_ = 
            other.connectionAttempts_;

        connectionTimeout_ = 
            other.connectionTimeout_;

        sendTimeout_ = 
            other.sendTimeout_;
    }

public:
    /// Initializes instance with default values. 
    /// 
    /// By default, feed A is used as the primary source 
    /// of market recovery data with fail-over to the feed B. 
    /// Heartbeats are expected within 2 seconds periodicity.
    TcpRecoveryFeedSettings(
        const SettingGroup* group = NULL)
        : Base(
            group, 
            RecoveryFeedLayout::
            FeedAOnly,
            2)
        , connectionAttempts_(3)
        , connectionTimeout_(500)
        , sendTimeout_(5000)
    {
    }

    /// Initializes the instance 
    /// as a copy of the other one. 
    TcpRecoveryFeedSettings(
        const 
        TcpRecoveryFeedSettings& other)
        : Base(
            static_cast
            <const Base&>
            (other))
        , connectionAttempts_(
            other.connectionAttempts_)
        , connectionTimeout_(
            other.connectionTimeout_)
        , sendTimeout_(
            other.sendTimeout_)
    {
    }

    /// Finalizes the instance. 
    ~TcpRecoveryFeedSettings()
    {
    }

    /// Number of times the Handler must try 
    /// recovering from the other feed if it 
    /// fails to recover from the primary one.
    /// 
    /// @note Default value is '3'. 
    UInt32 
    connectionAttempts() const
    {
        return connectionAttempts_;
    }

    /// Number of times the Handler must try 
    /// recovering from the other feed if it 
    /// fails to recover from the primary one.
    void 
    connectionAttempts(
        UInt32 attemptQty)
    {
        group().
            controlAssignment
            (
                "Connection Attempts", 
                connectionAttempts_,
                attemptQty
            );
    }

    /// Interval between the attempts to receive 
    /// missed packets via the TCP recovery feed if 
    /// previous attempt either failed or was rejected.
    ///
    /// Interval is measured in milliseconds. 
    ///
    /// @note Default value is '500'. 
    UInt32 
    connectionTimeout() const
    {
        return connectionTimeout_;
    }

    /// Interval between the attempts to receive 
    /// missed packets via the TCP recovery feed if 
    /// previous attempt either failed or was rejected.
    ///
    /// Interval is measured in milliseconds. 
    void 
    connectionTimeout(
        UInt32 connectionTimeout)
    {
        group().
            controlAssignment
            (
                "Connection Timeout",
                connectionTimeout_, 
                connectionTimeout
            );
    }

    /// Time limit for the send operation.
    ///
    /// Value is measured in milliseconds. 
    ///
    /// @note Default value is '5000'. 
    UInt32 
    sendTimeout() const
    {
        return sendTimeout_;
    }

    /// Time limit for the send operation.
    ///
    /// Value is measured in milliseconds. 
    void 
    sendTimeout(
        UInt32 sendTimeout)
    {
        group().
            controlAssignment
            (
                "Send Timeout",
                sendTimeout_, 
                sendTimeout
            );
    }

    /// Re-initializes the instance 
    /// as a copy of the other one. 
    TcpRecoveryFeedSettings& 
    operator =(
        const 
        TcpRecoveryFeedSettings& other)
    {
        group().
            controlAssignment
            (
                "TCP Recovery Feed Settings",
                &TcpRecoveryFeedSettings::assignNoControl,
                *this,
                other
            );

        return *this;
    }
};

/// Serializes feed settings into string.
ONIXS_CONFLATEDUDP_EXPORTED
void
toStr(
    std::string&, 
    const TcpRecoveryFeedSettings&);

/// Serializes feed settings into string.
inline
std::string
toStr(
    const TcpRecoveryFeedSettings& settings)
{
    std::string str;

    toStr(str, settings);

    return str;
}

/// Defines feed layout alternates available 
/// for real-time feed like incremental one. 
ONIXS_CONFLATEDUDP_LTWT_STRUCT RealtimeFeedLayout
{
    /// Integral type used as basement for constants. 
    typedef UInt32 Base;

    enum Enum
    {
        /// Indicates only feed A is used as source for market data. 
        FeedAOnly,

        /// Indicates only feed B is used as source for market data. 
        FeedBOnly,

        /// Feed A is used as primary source of market data. If Handler
        /// detects absence of market data on feed A, it switches to 
        /// feed B to continue market data processing. Feed B is used 
        /// by Handler until market data absence is detected on it. In 
        /// that case Handler will switch back to feed A. In other words,
        /// this layout instructs Handler to cycle between feeds if data
        /// absence is detected starting from feed A.
        FeedAWithFailoverToFeedB,

        /// Feed B is used as primary source of market data. If Handler
        /// detects absence of market data on feed B, it switches to 
        /// feed A to continue market data processing. Feed A is used 
        /// by Handler until market data absence is detected on it. In 
        /// that case Handler will switch back to feed B. In other words,
        /// this layout instructs Handler to cycle between feeds if data
        /// absence is detected starting from feed B.
        FeedBWithFailoverToFeedA,

        /// Handler arbitrates between both feeds A and B. 
        BothFeedsWithArbitrage
    };
};

/// Appends string presentation of feed layout.
ONIXS_CONFLATEDUDP_EXPORTED
void
toStr(
    std::string&, 
    RealtimeFeedLayout::Enum);

/// Returns string presentation of feed layout.
inline 
std::string
toStr(
    RealtimeFeedLayout::Enum layout)
{
    std::string str;
    
    toStr(str, layout);
    
    return str;
}

/// Collection of parameters affecting real-time feeds behavior. 
ONIXS_CONFLATEDUDP_LTWT_CLASS 
RealtimeFeedSettings
: public FeedSettingsBase
  <
    RealtimeFeedLayout::Enum
  >
{
    friend
    ONIXS_CONFLATEDUDP_LTWT_CLASS_DECL
    (
        FeedSettings
    );

    typedef 
    FeedSettingsBase
    <
        RealtimeFeedLayout::Enum
    >
    Base;

    UInt32 outOfOrderPacketMaxInterval_;
    UInt32 lostPacketWaitTime_;

    void
    assignNoControl(
        const RealtimeFeedSettings& other)
    {
        Base::assignNoControl(other);

        outOfOrderPacketMaxInterval_ = 
            other.outOfOrderPacketMaxInterval_;

        lostPacketWaitTime_ = 
            other.lostPacketWaitTime_;
    }

public:
    /// Initializes instance with default values. 
    ///
    /// By default, arbitrage between feeds A and B is done.
    /// Heartbeats are expected within 30 seconds periodicity.
    RealtimeFeedSettings(
        const SettingGroup* group = NULL)
      : Base(
          group, 
          RealtimeFeedLayout::
          BothFeedsWithArbitrage,
          30)
      , outOfOrderPacketMaxInterval_(3)
      , lostPacketWaitTime_(100000)
    {
    }

    /// Initializes the instance 
    /// as a copy of the other one. 
    RealtimeFeedSettings(
        const 
        RealtimeFeedSettings& other)
        : Base(
            static_cast
            <const Base&>
            (other))
        , outOfOrderPacketMaxInterval_(
            other.outOfOrderPacketMaxInterval_)
        , lostPacketWaitTime_(
            other.lostPacketWaitTime_)
    {
    }

    /// Finalizes the instance.
    ~RealtimeFeedSettings()
    {
    }

    /// Defines a threshold used by the Handler 
    /// while handling out-of-order incoming packets.
    ///
    /// Due to the unreliable nature of multicast, packets may be missed 
    /// or received in an order different from the expected. The Handler 
    /// uses the given parameter to establish a threshold for incoming 
    /// packets whose sequence numbers are greater than expected unless 
    /// the expected packets are received or recognized as lost. 
    /// 
    /// When the Handler receives a packet with the sequence number higher 
    /// than expected, it considers the incoming packet as out-of-order. It 
    /// puts the packet into an internal queue if its sequence number does 
    /// not exceed the established threshold. The threshold represents the 
    /// sum of the last accepted packet's sequence number and the value of 
    /// the given parameter. 
    /// 
    /// Packets are queued unless the expected ones are received, or their 
    /// sequence numbers exceed the threshold, or the time limit is reached. 
    /// If the incoming packet's sequence number exceeds the established 
    /// threshold, the Handler raises the gap event. 
    /// 
    /// If arbitrage between primary and secondary feeds is enabled, the 
    /// Handler does not trigger the gap event until incoming packets from 
    /// both feeds exceed the established threshold.
    ///
    /// @see 'lostPacketWaitTime' parameter for more information.
    ///
    /// @note The default value is '3'.
    UInt32 
    outOfOrderPacketMaxInterval() const
    {
        return outOfOrderPacketMaxInterval_;
    }

    /// Defines value of threshold used by the Handler 
    /// while handling out-of-order incoming packets.
    void 
    outOfOrderPacketMaxInterval(
        UInt32 intervalLength)
    {
        group().
            controlAssignment
            (
                "Out Of Order Packet Max Interval",
                outOfOrderPacketMaxInterval_, 
                intervalLength
            );
    }

    /// Indicates the time limit for the Handler while waiting 
    /// for expected packets before they are considered lost.
    /// 
    /// When the Handler receives a packet with the sequence number greater 
    /// than expected, it considers the received data as out-of-order. The 
    /// Handler resumes normal data processing if it receives missing data 
    /// during the given time interval.
    /// 
    /// However, if expected packets aren't received for a predefined time 
    /// frame, the Handler considers expected data as lost and raises the 
    /// gap event. The given parameter defines a time interval the Handler 
    /// waits for expected packets.
    ///
    /// @note The given parameter is used in combination with the 
    /// 'outOfOrderPacketMaxInterval' parameter.
    ///
    /// @see 'outOfOrderPacketMaxInterval' parameter for more information.
    ///
    /// The time interval is measured in microseconds (usec).
    ///
    /// @note The default value is '100000' (100 milliseconds).
    UInt32 
    lostPacketWaitTime() const
    {
        return lostPacketWaitTime_;
    }

    /// Defines the time limit for the Handler while waiting 
    /// for expected packets before they considered as lost.
    void 
    lostPacketWaitTime(
        UInt32 waitTime)
    {
        group().
            controlAssignment
            (
                "Lost Packet Wait Time",
                lostPacketWaitTime_, 
                waitTime
            );
    }

    /// Re-initializes the instance 
    /// as a copy of the other one. 
    RealtimeFeedSettings&
    operator =(
        const 
        RealtimeFeedSettings& other)
    {
        group().
            controlAssignment
            (
                "Realtime Feed Settings",
                &RealtimeFeedSettings::assignNoControl,
                *this,
                other
            );

        return *this;
    }
};

/// Serializes feed settings into string.
ONIXS_CONFLATEDUDP_EXPORTED
void
toStr(
    std::string&, 
    const RealtimeFeedSettings&);

/// Serializes feed settings into string.
inline
std::string
toStr(
    const RealtimeFeedSettings& settings)
{
    std::string str;

    toStr(str, settings);

    return str;
}

/// The parameters affecting all feeds 
/// involved into market data processing. 
ONIXS_CONFLATEDUDP_LTWT_CLASS 
FeedSettings : public SettingGroup
{
    // To let assignment be controlled 
    // by the master container. 
    friend 
    ONIXS_CONFLATEDUDP_LTWT_CLASS_DECL
    (
        HandlerSettings
    );

    std::string connectivityConfigurationFile_;

    PacketSize packetMaxSize_;

    RealtimeFeedSettings incrementalFeeds_;

    MulticastRecoveryFeedSettings instrumentFeeds_;
    MulticastRecoveryFeedSettings snapshotFeeds_;
    MulticastRecoveryFeedSettings mboSnapshotFeeds_;

    TcpRecoveryFeedSettings historicalFeeds_;

    NetFeedEngine* engine_;

    // Casts the given instance to an 
    // instance of SettingGroup class. 
    const 
    SettingGroup& 
    group() const
    {
        return *this;
    }

    // Re-initializes the given instance
    // as a copy of the other one without
    // involving assignment control service. 
    void
    assignNoControl(
        const FeedSettings& other)
    {
        connectivityConfigurationFile_ = 
            other.connectivityConfigurationFile_;

        packetMaxSize_ = 
            other.packetMaxSize_;

        incrementalFeeds_.
            assignNoControl(
                other.incrementalFeeds_);

        instrumentFeeds_.
            assignNoControl(
                other.instrumentFeeds_);

        snapshotFeeds_.
            assignNoControl(
                other.snapshotFeeds_);

        mboSnapshotFeeds_.
            assignNoControl(
                other.mboSnapshotFeeds_);

        historicalFeeds_.
            assignNoControl(
                other.historicalFeeds_);

        engine_ = other.engine_;
    }

    // Updates interfaces for all primary feeds 
    // without involving assignment control services. 
    void 
    assignFeedAInterfaces(
        const std::string& interfaces)
    {
        incrementalFeeds_.
            feedANetworkInterfaces_ = 

        instrumentFeeds_.
            feedANetworkInterfaces_ = 

        snapshotFeeds_.
            feedANetworkInterfaces_ = 

        mboSnapshotFeeds_.
            feedANetworkInterfaces_ = 

        historicalFeeds_.
            feedANetworkInterfaces_ = 

            interfaces;
    }

    // Updates interfaces for all primary feeds 
    // without involving assignment control services. 
    void 
    assignFeedBInterfaces(
        const std::string& interfaces)
    {
        incrementalFeeds_.
            feedBNetworkInterfaces_ = 

        instrumentFeeds_.
            feedBNetworkInterfaces_ = 

        snapshotFeeds_.
            feedBNetworkInterfaces_ = 

        mboSnapshotFeeds_.
            feedBNetworkInterfaces_ = 

        historicalFeeds_.
            feedBNetworkInterfaces_ = 

            interfaces;
    }

public:
    /// Initializes the instance with the default values. 
    FeedSettings(
        SettingAssignController* 
        controller = NULL)
        : SettingGroup(controller)
        , packetMaxSize_(1420)
        , incrementalFeeds_(&group())
        , instrumentFeeds_(&group())
        , snapshotFeeds_(&group())
        , mboSnapshotFeeds_(&group())
        , historicalFeeds_(&group())
        , engine_(NULL)
    {
    }

    /// Initializes the instance 
    /// as a copy of the other one. 
    FeedSettings(
        const FeedSettings& other)
        : SettingGroup()
        , connectivityConfigurationFile_(
            other.connectivityConfigurationFile_)
        , packetMaxSize_(
            other.packetMaxSize_)
        , incrementalFeeds_(
            other.incrementalFeeds_)
        , instrumentFeeds_(
            other.instrumentFeeds_)
        , snapshotFeeds_(
            other.snapshotFeeds_)
        , mboSnapshotFeeds_(
            other.mboSnapshotFeeds_)
        , historicalFeeds_(
            other.historicalFeeds_)
        , engine_(
            other.engine_)
    {
    }

    /// Path to the connectivity configuration file.
    const 
    std::string& 
    connectivityConfigurationFile() const
    {
        return connectivityConfigurationFile_;
    }

    /// Sets path to the connectivity configuration file. 
    void 
    connectivityConfigurationFile(
        const std::string& configurationFile)
    {
        group().
            controlAssignment
            (
                "Connectivity Configuration File", 
                connectivityConfigurationFile_,
                configurationFile
            );
    }

    /// Specifies one or more network interfaces to use for 
    /// "A" feeds while joining the multicast group; use 
    /// semi-colon delimited list if more than one.
    void 
    feedANetworkInterfaces(
        const std::string& interfaces)
    {
        group().
            controlAssignment
            (
                "Feed A Network Interfaces for All Feeds",
                &FeedSettings::assignFeedAInterfaces,
                *this,
                interfaces
            );
    }

    /// Specifies one or more network interfaces to use for 
    /// "B" feeds while joining the multicast group; use 
    /// semi-colon delimited list if more than one.
    void 
    feedBNetworkInterfaces(
        const std::string& interfaces)
    {
        group().
            controlAssignment
            (
                "Feed B Network Interfaces for All Feeds",
                &FeedSettings::assignFeedBInterfaces,
                *this,
                interfaces
            );
    }

    /// Max size for network packet transmitted by MDP.
    ///
    /// @note Default value is '1420'.
    PacketSize packetMaxSize() const
    {
        return packetMaxSize_;
    }

    /// Max size for network packet transmitted by MDP.
    void 
    packetMaxSize(
        PacketSize value)
    {
        group().
            controlAssignment
            (
                "Packet Max Size", 
                packetMaxSize_,
                value
            );
    }

    /// The settings related to incremental feeds. 
    const 
    RealtimeFeedSettings& 
    incrementalFeeds() const
    {
        return incrementalFeeds_;
    }

    /// The settings related to incremental feeds. 
    RealtimeFeedSettings& 
    incrementalFeeds()
    {
        return incrementalFeeds_;
    }

    /// The settings related to instrument feeds. 
    const 
    MulticastRecoveryFeedSettings& 
    instrumentFeeds() const
    {
        return instrumentFeeds_;
    }

    /// The settings related to instrument feeds. 
    MulticastRecoveryFeedSettings& 
    instrumentFeeds()
    {
        return instrumentFeeds_;
    }

    /// The settings related to snapshot feeds. 
    const 
    MulticastRecoveryFeedSettings& 
    snapshotFeeds() const
    {
        return snapshotFeeds_;
    }

    /// The settings related to snapshot feeds. 
    MulticastRecoveryFeedSettings& 
    snapshotFeeds()
    {
        return snapshotFeeds_;
    }

    /// The settings related to snapshot feeds. 
    const 
    MulticastRecoveryFeedSettings& 
    mboSnapshotFeeds() const
    {
        return mboSnapshotFeeds_;
    }

    /// The settings related to snapshot feeds. 
    MulticastRecoveryFeedSettings& 
    mboSnapshotFeeds()
    {
        return mboSnapshotFeeds_;
    }

    /// The settings related to historical (TCP recovery) feeds. 
    const 
    TcpRecoveryFeedSettings& 
    historicalFeeds() const
    {
        return historicalFeeds_;
    }

    /// The settings related to historical (TCP Recovery) feeds. 
    TcpRecoveryFeedSettings& 
    historicalFeeds()
    {
        return historicalFeeds_;
    }

    /// Instance of the Feed Engine to be used by the Handler.
    /// Null instance means no feed engine is yet defined. 
    NetFeedEngine* engine() const
    {
        return engine_;
    }

    /// Defines instance of the Feed Engine to be used by the Handler.
    void
    engine(
        NetFeedEngine* engine)
    {
        group().
            controlAssignment
            (
                "Feed Engine", 
                engine_, 
                engine
            );
    }

    /// Re-initializes the instance 
    /// as a copy of the other one. 
    FeedSettings&
    operator =(
        const FeedSettings& other)
    {
        group().
            controlAssignment
            (
                "Feed Settings",
                &FeedSettings::assignNoControl,
                *this, 
                other
            );

        return *this;
    }
};

/// Serializes feed settings into string.
ONIXS_CONFLATEDUDP_EXPORTED
void
toStr(
    std::string&, 
    const FeedSettings&);

/// Serializes feed settings into string.
inline
std::string
toStr(
    const FeedSettings& settings)
{
    std::string str;

    toStr(str, settings);

    return str;
}

ONIXS_CONFLATEDUDP_NAMESPACE_END