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
);

typedef
std::vector<std::string>
FileList;

ONIXS_CONFLATEDUDP_EXPORTED
void
gatherLogFiles(
    FileList&, 
    ChannelId,
    const std::string&);

ONIXS_CONFLATEDUDP_EXPORTED
void
gatherLogFiles(
    FileList&, 
    ChannelId,
    const std::string&,
    const std::string&);

ONIXS_CONFLATEDUDP_EXPORTED
void
gatherFiles(
    FileList&,
    const std::string&,
    const std::string&);
 
#if !defined (ONIXS_CONFLATEDUDP_NO_DEPRECATED)

inline 
void
gatherPcapFiles(
    FileList& files,
    const std::string& location,
    const std::string& ext)
{
    gatherFiles(files, location, ext);
}
 
#endif // !ONIXS_CONFLATEDUDP_NO_DEPRECATED

ONIXS_CONFLATEDUDP_LTWT_STRUCT HandlerSettingsUse
{
    enum Enum
    {
        AsIs,

        Suggested
    };
};

ONIXS_CONFLATEDUDP_LTWT_CLASS ReplaySpan
{
    Timestamp begin_;
    Timestamp end_;
 
public:
    ReplaySpan()
        : begin_()
        , end_()
    {
    }

    ReplaySpan(
        const Timestamp& begin,
        const Timestamp& end)
        : begin_(begin)
        , end_(end)
    {
    }

    ReplaySpan(
        const ReplaySpan& other)
        : begin_(other.begin_)
        , end_(other.end_)
    {
    }

    bool empty() const
    {
        return (begin_ >= end_);
    }

    bool 
    contain(
        const Timestamp& timestamp) const
    {
        return (
            begin_ <= timestamp && 
            timestamp < end_);
    }

    const Timestamp& begin() const
    {
        return begin_;
    }

    void 
    begin(
        const Timestamp& value)
    {
        begin_ = value;
    }

    const Timestamp& end() const
    {
        return end_;
    }

    void
    end(
        const Timestamp& value)
    {
        end_ = value;
    }

    ReplaySpan& 
    operator =(
        const ReplaySpan& other)
    {
        begin_ = other.begin_;
        end_ = other.end_;
 
        return *this;
    }
};

ONIXS_CONFLATEDUDP_LTWT_STRUCT ReplaySpeed
{
    enum Enum
    {
        NoDelay = 0, 

        Original = 1,

        X2 = 2
    }; 
};

template
<
    class DataSource,
    class DataSourceLess = std::less<DataSource>
>
class ReplaySupplements
{
public:
    typedef 
    std::map
    <
        DataSource, 
        DataSource,
        DataSourceLess
    >
    Aliases;

    ReplaySupplements()
      : settingsUse_(
          HandlerSettingsUse::
          Suggested)
      , aliases_()
      , timeSpan_()
      , speed_(
          ReplaySpeed::
          NoDelay)
    {
    }

    ReplaySupplements(
        const ReplaySupplements& other)
        : settingsUse_(
            other.settingsUse_)
        , aliases_(
            other.aliases_)
        , timeSpan_(
            other.timeSpan_)
        , speed_(
            other.speed_)
    {
    }

    HandlerSettingsUse::Enum 
    settingsUse() const
    {
        return settingsUse_;
    }

    void 
    settingsUse(
        HandlerSettingsUse::Enum policy)
    {
        settingsUse_ = policy;
    }

    const 
    Aliases& 
    aliases() const
    {
        return aliases_;
    }

    Aliases& aliases()
    {
        return aliases_;
    }

    const 
    ReplaySpan& 
    timeSpan() const
    {
        return timeSpan_;
    }

    ReplaySpan& 
    timeSpan()
    {
        return timeSpan_;
    }

    ReplaySpeed::Enum
    speed() const
    {
        return speed_;
    }

    void 
    speed(
        ReplaySpeed::Enum policy)
    {
        speed_ = policy;
    }

    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_;
};

typedef 
ReplaySupplements
<
    NetFeedId
>
LogReplaySupplements;

typedef 
LogReplaySupplements::Aliases
FeedIdAliases;

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:
    PcapReplaySupplements()
    {
        settingsUse(HandlerSettingsUse::AsIs);
    }

    HandlerSettingsUse::Enum settingsUse() const
    {
        return HandlerSettingsUse::AsIs;
    }
};

typedef
PcapReplaySupplements::Aliases
NetAddressAliases;

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:
    DatamineReplaySupplements()
    {
        settingsUse(HandlerSettingsUse::AsIs);
    }

    HandlerSettingsUse::Enum settingsUse() const
    {
        return HandlerSettingsUse::AsIs;
    }
};
            
typedef
DatamineReplaySupplements::Aliases
ChannelIdAliases;

ONIXS_CONFLATEDUDP_EXPORTED
void 
replayLogFiles(
    const FileList&, 
    Handler**, 
    size_t, 
    const LogReplaySupplements&);

inline 
void 
replayLogFiles(
    const FileList& logs, 
    Handler& handler, 
    const LogReplaySupplements& supplements)
{
    Handler* handlers[] = { &handler };
 
    replayLogFiles(
        logs, 
        handlers, 
        1, 
        supplements);
}

inline 
void 
replayLogFiles(
    const FileList& logs, 
    Handler** handlers, 
    size_t handlerQty)
{
    replayLogFiles(
        logs, 
        handlers, 
        handlerQty,
        LogReplaySupplements());
}

inline 
void 
replayLogFiles(
    const FileList& logs, 
    Handler& handler)
{
    Handler* handlers[] = { &handler };
 
    replayLogFiles(logs, handlers, 1);
}

ONIXS_CONFLATEDUDP_LTWT_STRUCT UseHandlerSettingsAsIs {};

inline 
void 
replayLogFiles(
    const FileList& logs, 
    Handler** handlers, 
    size_t handlerQty, 
    const UseHandlerSettingsAsIs&)
{
    LogReplaySupplements supplements;
 
    supplements.
        settingsUse(
            HandlerSettingsUse::
            AsIs);
 
    replayLogFiles(
        logs, 
        handlers, 
        handlerQty,
        supplements);
}

inline 
void 
replayLogFiles(
    const FileList& logs, 
    Handler& handler,
    const UseHandlerSettingsAsIs& marker)
{
    Handler* handlers[] = { &handler };
 
    replayLogFiles(logs, handlers, 1, marker);
}

ONIXS_CONFLATEDUDP_EXPORTED
void
replayPcapFiles(
    const FileList&,
    Handler**,
    size_t,
    const PcapReplaySupplements&);

inline
void
replayPcapFiles(
    const FileList& logs,
    Handler& handler,
    const PcapReplaySupplements& supplements)
{
    Handler* handlers[] = { &handler };
 
    replayPcapFiles(logs, handlers, 1, supplements);
}

inline
void
replayPcapFiles(
    const FileList& logs,
    Handler& handler)
{
    replayPcapFiles(
        logs,
        handler,
        PcapReplaySupplements());
}

ONIXS_CONFLATEDUDP_EXPORTED
void
replayDatamineFiles(
    const FileList&,
    Handler**,
    size_t,
    const DatamineReplaySupplements&);

inline
void
replayDatamineFiles(
    const FileList& logs,
    Handler& handler,
    const DatamineReplaySupplements& supplements)
{
    Handler* handlers[] = { &handler };
 
    replayDatamineFiles(
        logs, 
        handlers, 
        1, 
        supplements);
}

inline
void
replayDatamineFiles(
    const FileList& logs,
    Handler& handler)
{
    replayDatamineFiles(
        logs,
        handler,
        DatamineReplaySupplements());
}
 
ONIXS_CONFLATEDUDP_NAMESPACE_END