Replay.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 <vector>
#include <map>
#include <functional>

#include <OnixS/CME/ConflatedUDP/Integral.h>
#include <OnixS/CME/ConflatedUDP/Time.h>

#include <OnixS/CME/ConflatedUDP/Domain.h>
#include <OnixS/CME/ConflatedUDP/FeedAttributes.h>
#include <OnixS/CME/ConflatedUDP/FeedConnection.h>
#include <OnixS/CME/ConflatedUDP/SessionSettings.h>

ONIXS_CONFLATEDUDP_NAMESPACE_BEGIN

// A bit of forward declarations. 
ONIXS_CONFLATEDUDP_EXPORTED_CLASS_DECL
(
    Handler
);

/// Ordered list of logs to be replayed.
typedef
std::vector<std::string>
FileList;

/// Gathers log files logs which are available for 
/// given channel and are stored in a given folder.
/// Gathering assumes log files are named by log file 
/// naming routine exposed by given SDK.
ONIXS_CONFLATEDUDP_EXPORTED
void
gatherLogFiles(
    FileList&, 
    ChannelId,
    const std::string&);

/// Gathers log files logs which are available for 
/// given channel and are stored in a given folder.
/// Gathering assumes log files are named by log file 
/// naming routine exposed by given SDK. In contrast
/// to other overloads, given one allows to define
/// prefix pattern for logs to be gathered. 
ONIXS_CONFLATEDUDP_EXPORTED
void
gatherLogFiles(
    FileList&, 
    ChannelId,
    const std::string&,
    const std::string&);

/// Gathers files which are stored in the given folder with 
/// the given extension. Gathered files are sorted by name.
/// 
/// In contrast to the gatherLogFiles function gathering log 
/// files, which collects log files in exact order the files 
/// were produced by a logger, the given one represents a generic 
/// routine finding files according to the given pattern (extension).
ONIXS_CONFLATEDUDP_EXPORTED
void
gatherFiles(
    FileList&,
    const std::string&,
    const std::string&);

#if !defined (ONIXS_CONFLATEDUDP_NO_DEPRECATED)

/// Gathers files which are stored in the given folder with 
/// the given extension. Gathered files are sorted by name.
/// 
/// \warning The given function is deprecated. 
/// Consider using `gatherFiles` instead. 
inline 
void
gatherPcapFiles(
    FileList& files,
    const std::string& location,
    const std::string& ext)
{
    gatherFiles(files, location, ext);
}

#endif // !ONIXS_CONFLATEDUDP_NO_DEPRECATED

/// Defines whether processing and other settings 
/// must be extracted from logs and used during the 
/// replay, or the original settings as they were 
/// defined by replay invoker must be used. 
ONIXS_CONFLATEDUDP_LTWT_STRUCT HandlerSettingsUse
{
    enum Enum
    {
        /// Handler settings aren't touched and 
        /// used as they are during the replay.
        AsIs,

        /// Settings affecting the way the data 
        /// is processed must be extracted from 
        /// the logs and applied to the Handlers 
        /// before replay starts. 
        Suggested
    };
};

/// Defines range of log entries to be replayed. 
ONIXS_CONFLATEDUDP_LTWT_CLASS ReplaySpan
{
    Timestamp begin_;
    Timestamp end_;

public:
    /// Initializes empty span. 
    ReplaySpan()
        : begin_()
        , end_()
    {
    }

    /// Initializes the instance 
    /// according to the given bounds. 
    ReplaySpan(
        const Timestamp& begin,
        const Timestamp& end)
        : begin_(begin)
        , end_(end)
    {
    }

    /// Initializes the instance 
    /// as a copy of the other one. 
    ReplaySpan(
        const ReplaySpan& other)
        : begin_(other.begin_)
        , end_(other.end_)
    {
    }

    /// Indicates whether span is empty or not. 
    bool empty() const
    {
        return (begin_ >= end_);
    }

    /// Indicates whether the given timestamp 
    /// belongs to the given time span. 
    bool 
    contain(
        const Timestamp& timestamp) const
    {
        return (
            begin_ <= timestamp && 
            timestamp < end_);
    }

    /// Indicates the beginning of the range. 
    const Timestamp& begin() const
    {
        return begin_;
    }

    /// Updates the beginning of the range. 
    void 
    begin(
        const Timestamp& value)
    {
        begin_ = value;
    }

    /// Indicates the end of the range. 
    const Timestamp& end() const
    {
        return end_;
    }

    /// Indicates the end of the range. 
    void
    end(
        const Timestamp& value)
    {
        end_ = value;
    }

    /// Re-initializes as a copy of the other one. 
    ReplaySpan& 
    operator =(
        const ReplaySpan& other)
    {
        begin_ = other.begin_;
        end_ = other.end_;

        return *this;
    }
};

/// Controls speed of market data replay. 
ONIXS_CONFLATEDUDP_LTWT_STRUCT ReplaySpeed
{
    /// Controls speed of market data replay. 
    enum Enum
    {
        /// Replays run at maximal speed. 
        NoDelay = 0, 

        /// Data is replayed with the original speed. 
        Original = 1,

        /// Data is replayed two times faster in 
        /// compare to the original speed at which 
        /// the Handler was receiving that data.
        X2 = 2
    }; 
};

/// Various supplemental settings affecting 
/// the way the logged data is replayed. 
template
<
    class DataSource,
    class DataSourceLess = std::less<DataSource>
>
class ReplaySupplements
{
public:
    /// The table of data source aliases.
    typedef 
    std::map
    <
        DataSource, 
        DataSource,
        DataSourceLess
    >
    Aliases;

    /// Initializes the settings with the default values. 
    ReplaySupplements()
      : settingsUse_(
          HandlerSettingsUse::
          Suggested)
      , aliases_()
      , timeSpan_()
      , speed_(
          ReplaySpeed::
          NoDelay)
    {
    }

    /// Initializes as a copy of the other one. 
    ReplaySupplements(
        const ReplaySupplements& other)
        : settingsUse_(
            other.settingsUse_)
        , aliases_(
            other.aliases_)
        , timeSpan_(
            other.timeSpan_)
        , speed_(
            other.speed_)
    {
    }

    /// Handler settings use policy. 
    HandlerSettingsUse::Enum 
    settingsUse() const
    {
        return settingsUse_;
    }

    /// Defines handler settings use policy. 
    void 
    settingsUse(
        HandlerSettingsUse::Enum policy)
    {
        settingsUse_ = policy;
    }

    /// Aliases to be used during the replay. 
    ///
    /// Aliases allow redirecting data from one source 
    /// (feed, multicast group, channel, etc.) to the other 
    /// one. 
    const 
    Aliases& 
    aliases() const
    {
        return aliases_;
    }

    /// Aliases to be used during the replay. 
    ///
    /// Aliases allow redirecting data from one source 
    /// (feed, multicast group, channel, etc.) to the other 
    /// one. 
    Aliases& aliases()
    {
        return aliases_;
    }

    /// Time span for which entries are to be processed.
    const 
    ReplaySpan& 
    timeSpan() const
    {
        return timeSpan_;
    }

    /// Time span for which entries are to be processed.
    ReplaySpan& 
    timeSpan()
    {
        return timeSpan_;
    }

    /// Indicates processing speed policy.
    ReplaySpeed::Enum
    speed() const
    {
        return speed_;
    }

    /// Defines processing speed.
    void 
    speed(
        ReplaySpeed::Enum policy)
    {
        speed_ = policy;
    }

    /// Re-initializes as a copy of the other one. 
    ReplaySupplements&
    operator =(
        const ReplaySupplements& other)
    {
        settingsUse_ = 
            other.settingsUse_;

        aliases_ = 
            other.aliases_;

        timeSpan_ = 
            other.timeSpan_;

        speed_ = 
            other.speed_;

        return *this;
    }

private:
    HandlerSettingsUse::Enum settingsUse_;
    Aliases aliases_;
    
    ReplaySpan timeSpan_;
    ReplaySpeed::Enum speed_;
};

/// Replay supplements for log replay functionality. 
typedef 
ReplaySupplements
<
    NetFeedId
>
LogReplaySupplements;

/// Collection of logged data sources (feed 
/// identifiers) to be used by the Log Replay 
/// to replace logged sources with the sources 
/// used by Handlers involved into replay. 
typedef 
LogReplaySupplements::Aliases
FeedIdAliases;

/// Replay supplements for the PCAP replay functionality.
ONIXS_CONFLATEDUDP_LTWT_CLASS 
PcapReplaySupplements 
: public ReplaySupplements
  <
    NetFeedConnection,
    NetFeedConnectionLess
  >
{
    typedef 
    ReplaySupplements
    <
        NetFeedConnection,
        NetFeedConnectionLess
    >
    Base;

    // Not applicable for the PCAP replay as no 
    // parameters are stored in the captured files. 
    using Base::settingsUse;

public:
    /// Initializes settings with the default values. 
    PcapReplaySupplements()
    {
        settingsUse(HandlerSettingsUse::AsIs);
    }

    /// Settings aren't stored in PCAPs 
    /// thus constant value is returned. 
    HandlerSettingsUse::Enum settingsUse() const
    {
        return HandlerSettingsUse::AsIs;
    }
};

/// Collection of data sources (feed identifiers) 
/// to be used by the PCAP file replay to replace 
/// captured sources with the sources used by Handlers 
/// involved into replay.
typedef
PcapReplaySupplements::Aliases
NetAddressAliases;

/// Replay supplements for the CME DataMine
/// historical data replay functionality.
ONIXS_CONFLATEDUDP_LTWT_CLASS
DatamineReplaySupplements
: public ReplaySupplements<ChannelId>
{
    typedef
    ReplaySupplements<ChannelId>
    Base;

    // Not applicable for the Datamine replay as no 
    // parameters are stored in the captured files. 
    using Base::settingsUse;

public:
    /// Initializes settings with the default values.
    DatamineReplaySupplements()
    {
        settingsUse(HandlerSettingsUse::AsIs);
    }

    /// Settings aren't stored in Datamine 
    /// thus constant value is returned. 
    HandlerSettingsUse::Enum settingsUse() const
    {
        return HandlerSettingsUse::AsIs;
    }
};
            
/// Collection of channels to be used by the CME Datamine
/// historical file replay to replace captured sources 
/// with the sources used by Handlers involved into replay.
typedef
DatamineReplaySupplements::Aliases
ChannelIdAliases;

/// Extracts market data stored in the given 
/// log files and pushes it to the given handlers 
/// for further processing. 
ONIXS_CONFLATEDUDP_EXPORTED
void 
replayLogFiles(
    const FileList&, 
    Handler**, 
    size_t, 
    const LogReplaySupplements&);

/// Extracts market data stored in the given 
/// log files and pushes it to the given handler 
/// for further processing. 
inline 
void 
replayLogFiles(
    const FileList& logs, 
    Handler& handler, 
    const LogReplaySupplements& supplements)
{
    Handler* handlers[] = { &handler };

    replayLogFiles(
        logs, 
        handlers, 
        1, 
        supplements);
}

/// Processes market data stored in the log 
/// files according to specified settings. 
inline 
void 
replayLogFiles(
    const FileList& logs, 
    Handler** handlers, 
    size_t handlerQty)
{
    replayLogFiles(
        logs, 
        handlers, 
        handlerQty,
        LogReplaySupplements());
}

/// Processes market data stored in the log 
/// files according to specified settings. 
inline 
void 
replayLogFiles(
    const FileList& logs, 
    Handler& handler)
{
    Handler* handlers[] = { &handler };

    replayLogFiles(logs, handlers, 1);
}

/// A Marker instructing the log replay procedure to 
/// use Hander settings as they are without applying 
/// any modifications based on logged information. 
ONIXS_CONFLATEDUDP_LTWT_STRUCT UseHandlerSettingsAsIs {};

/// Processes market data stored in the log 
/// files according to specified settings. 
inline 
void 
replayLogFiles(
    const FileList& logs, 
    Handler** handlers, 
    size_t handlerQty, 
    const UseHandlerSettingsAsIs&)
{
    LogReplaySupplements supplements;

    supplements.
        settingsUse(
            HandlerSettingsUse::
            AsIs);

    replayLogFiles(
        logs, 
        handlers, 
        handlerQty,
        supplements);
}

/// Processes market data stored in the log 
/// files according to specified settings. 
inline 
void 
replayLogFiles(
    const FileList& logs, 
    Handler& handler,
    const UseHandlerSettingsAsIs& marker)
{
    Handler* handlers[] = { &handler };

    replayLogFiles(logs, handlers, 1, marker);
}

/// Replays the given list of PCAP files for the 
/// given Handlers according to the given settings. 
ONIXS_CONFLATEDUDP_EXPORTED
void
replayPcapFiles(
    const FileList&,
    Handler**,
    size_t,
    const PcapReplaySupplements&);

/// Replays the given list of PCAP files for the 
/// given Handler according to the given settings. 
inline
void
replayPcapFiles(
    const FileList& logs,
    Handler& handler,
    const PcapReplaySupplements& supplements)
{
    Handler* handlers[] = { &handler };

    replayPcapFiles(logs, handlers, 1, supplements);
}

/// Replays the given list of PCAP files for the 
/// given Handler according to the default settings. 
inline
void
replayPcapFiles(
    const FileList& logs,
    Handler& handler)
{
    replayPcapFiles(
        logs,
        handler,
        PcapReplaySupplements());
}

/// Replays the given list of Datamine files for the
/// given Handlers according to the given settings.
ONIXS_CONFLATEDUDP_EXPORTED
void
replayDatamineFiles(
    const FileList&,
    Handler**,
    size_t,
    const DatamineReplaySupplements&);

/// Replays the given list of Datamine files for the
/// given Handlers according to the given settings.
inline
void
replayDatamineFiles(
    const FileList& logs,
    Handler& handler,
    const DatamineReplaySupplements& supplements)
{
    Handler* handlers[] = { &handler };

    replayDatamineFiles(
        logs, 
        handlers, 
        1, 
        supplements);
}

/// Replays the given list of historical data for the 
/// given Handler according to the default settings. 
inline
void
replayDatamineFiles(
    const FileList& logs,
    Handler& handler)
{
    replayDatamineFiles(
        logs,
        handler,
        DatamineReplaySupplements());
}

ONIXS_CONFLATEDUDP_NAMESPACE_END