MulticastSender.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 <unordered_map>
#include <memory>
 
#include <OnixS/CME/MDH/FeedAttributes.h>
#include <OnixS/CME/MDH/FeedSettings.h>
#include <OnixS/CME/MDH/ReplayDelayer.h>
#include <OnixS/CME/MDH/threading/Future.h>
 
namespace OnixS { namespace Networking { class MulticastClient; }}
 
ONIXS_CME_MDH_TESTING_NAMESPACE_BEGIN

class ONIXS_CMEMDH_EXPORTED MulticastTarget
{
public:
    static constexpr PacketSize DefaultMaxPacketSize = 1420;

    explicit MulticastTarget(
            const RealtimeFeedSettings& feedSettings,
            Messaging::TimeSpan arbitrageDelay = Messaging::TimeSpan{},
            ReplayDelayer& delayPolicy = CombinedReplayDelayer::service(),
            PacketSize packetMaxSize = DefaultMaxPacketSize);

    explicit MulticastTarget(
        const MulticastRecoveryFeedSettings& feedSettings,
        Messaging::TimeSpan arbitrageDelay = Messaging::TimeSpan{},
        ReplayDelayer& delayPolicy = CombinedReplayDelayer::service(),
        PacketSize packetMaxSize = DefaultMaxPacketSize);

    ~MulticastTarget();

    ONIXS_CMEMDH_NODISCARD
    Threading::Event send(const void* data, size_t dataSize);

    void sendA(const void* data, size_t dataSize);

    void sendB(const void* data, size_t dataSize);

    void sendPrimary(const void* data, size_t dataSize);

    void sendSecondary(const void* data, size_t dataSize);

    ONIXS_CMEMDH_NODISCARD
    NetFeedRole::Enum primaryFeed() const noexcept;

    ONIXS_CMEMDH_NODISCARD
    NetFeedRole::Enum secondaryFeed() const noexcept;

    ONIXS_CMEMDH_NODISCARD
    bool hasSecondary() const noexcept;
 
    MulticastTarget(const MulticastTarget&) = delete;
    MulticastTarget& operator=(const MulticastTarget&) = delete;
 
private:
    using MulticastClientPtr = std::unique_ptr<OnixS::Networking::MulticastClient>;
    class AsyncSecondarySender;
 
    static void construct(MulticastClientPtr& client, const FeedConnectionSettings& connection);
    static void constructIfConfigured(MulticastClientPtr& client, const FeedConnectionSettings& connection);
    static void destruct(MulticastClientPtr& client);
    static void send(MulticastClientPtr& client, const void* data, size_t dataSize);
    void validateDataSize(size_t dataSize) const;
 
    MulticastClientPtr& getFeed(NetFeedRole::Enum role) noexcept;
    const MulticastClientPtr& getFeed(NetFeedRole::Enum role) const noexcept;
 
    const Messaging::TimeSpan arbitrageDelay_ = Messaging::TimeSpan{};
    ReplayDelayer& delayPolicy_;
    const PacketSize packetMaxSize_;
    NetFeedRole::Enum primaryFeed_ = NetFeedRole::A;
 
    MulticastClientPtr feedA_;
    MulticastClientPtr feedB_;
    std::unique_ptr<AsyncSecondarySender> asyncSecondarySender_;
};
 
using MulticastTargetPtr = std::unique_ptr<MulticastTarget>;

class ONIXS_CMEMDH_EXPORTED MulticastSender
{
public:
    explicit MulticastSender(
            const FeedSettings& feedSettings,
            Messaging::TimeSpan arbitrageDelay = Messaging::TimeSpan{},
            ReplayDelayer& delayPolicy = CombinedReplayDelayer::service());

    ~MulticastSender();

    ONIXS_CMEMDH_NODISCARD
    Threading::Event send(NetFeedType::Enum target, const void* data, size_t dataSize);

    ONIXS_CMEMDH_NODISCARD
    MulticastTargetPtr& getTarget(NetFeedType::Enum target);
 
    MulticastSender(const MulticastSender&) = delete;
    MulticastSender& operator=(const MulticastSender&) = delete;
 
private:
    std::unordered_map<NetFeedType::Enum, MulticastTargetPtr> targets_;
};
 
ONIXS_CME_MDH_TESTING_NAMESPACE_END