SessionSettings.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/MDH/messaging/Integral.h>
#include <OnixS/CME/MDH/SettingGroup.h>
 
ONIXS_CMEMDH_NAMESPACE_BEGIN

struct ONIXS_CMEMDH_LTWT JoinRecoveryOptions
{
    typedef Messaging::UInt32 Base;

    enum Enum
    {
        Disabled,

        Instruments,

        InstrumentsAndMarketState
    };
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, JoinRecoveryOptions::Enum);

inline std::string toStr(JoinRecoveryOptions::Enum recovery)
{
    std::string str;
 
    toStr(str, recovery);
 
    return str;
}

struct ONIXS_CMEMDH_LTWT GapAndErrorHandlingOptions
{
    typedef Messaging::UInt32 Base;

    enum Enum
    {
        RecoverMarketState,

        RecoverInstrumentsAndMarketState,

        ContinueProcessing
    };
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, GapAndErrorHandlingOptions::Enum);

inline std::string toStr(GapAndErrorHandlingOptions::Enum handling)
{
    std::string str;
 
    toStr(str, handling);
 
    return str;
}

struct ONIXS_CMEMDH_LTWT InstrumentRecoveryOptions
{
    typedef Messaging::UInt32 Base;
 
    enum Enum
    {
        Accurate,

        Fast
    };
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, InstrumentRecoveryOptions::Enum);

inline std::string toStr(InstrumentRecoveryOptions::Enum option)
{
    std::string str;
 
    toStr(str, option);
 
    return str;
}

struct ONIXS_CMEMDH_LTWT MarketRecoveryOptions
{
    typedef Messaging::UInt32 Base;
 
    enum Enum
    {
        MbpOnly,

        MboOnly,

        BothMboAndMbp
    };
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, MarketRecoveryOptions::Enum);

inline std::string toStr(MarketRecoveryOptions::Enum option)
{
    std::string str;
 
    toStr(str, option);
 
    return str;
}
 
ONIXS_CMEMDH_EXPORTED_CLASS_DECL(TcpRecoveryService);

class ONIXS_CMEMDH_LTWT TcpRecoverySessionSettings
{
public:
    TcpRecoverySessionSettings(const SettingGroup* group = nullptr)
        : group_(group ? *group : SettingGroup::null())
        , service_(nullptr)
        , attempts_(1)
        , servingTimeLimit_(10)
    {
    }

    TcpRecoverySessionSettings(const TcpRecoverySessionSettings& other)
        : group_(SettingGroup::null())
        , service_(other.service_)
        , attempts_(other.attempts_)
        , servingTimeLimit_(other.servingTimeLimit_)
    {
    }

    ~TcpRecoverySessionSettings() {}

    TcpRecoveryService* service() const
    {
        return service_;
    }

    TcpRecoverySessionSettings& service(TcpRecoveryService* service)
    {
        group_.controlAssignment("TCP Recovery Service Instance", service_, service);
 
        return *this;
    }

    Messaging::UInt32 attempts() const
    {
        return attempts_;
    }

    TcpRecoverySessionSettings& attempts(Messaging::UInt32 qty)
    {
        group_.controlAssignment("TCP Recovery Attempt Quantity", attempts_, qty);
 
        return *this;
    }

    Messaging::UInt32 servingTimeLimit() const
    {
        return servingTimeLimit_;
    }

    TcpRecoverySessionSettings& servingTimeLimit(Messaging::UInt32 servingTimeLimit)
    {
        group_.controlAssignment("TCP Recovery Serving Time Limit", servingTimeLimit_, servingTimeLimit);
 
        return *this;
    }

    TcpRecoverySessionSettings& operator=(const TcpRecoverySessionSettings& other)
    {
        group_.controlChange(
            "TCP Recovery Session Settings", &TcpRecoverySessionSettings::assignNoControl, *this, other
        );
 
        return *this;
    }
 
private:
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(SessionSettings);
 
    const SettingGroup& group_;
 
    TcpRecoveryService* service_;
 
    Messaging::UInt32 attempts_;
    Messaging::UInt32 servingTimeLimit_;
 
    // Re-initializes the instance as a copy of the
    // other one and bypassing assignment control.
    void assignNoControl(const TcpRecoverySessionSettings& other)
    {
        service_ = other.service_;
 
        attempts_ = other.attempts_;
 
        servingTimeLimit_ = other.servingTimeLimit_;
    }
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, const TcpRecoverySessionSettings&);

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

class ONIXS_CMEMDH_LTWT SessionSettings : public SettingGroup
{
public:
    SessionSettings(SettingChangeController* controller = nullptr)
        : SettingGroup(controller)
        , joinRecovery_(JoinRecoveryOptions::InstrumentsAndMarketState)
        , gapAndErrorHandling_(GapAndErrorHandlingOptions::RecoverMarketState)
        , instrumentRecovery_(InstrumentRecoveryOptions::Accurate)
        , marketRecovery_(MarketRecoveryOptions::BothMboAndMbp)
        , tcpRecovery_(&group())
    {
    }

    SessionSettings(const SessionSettings& other)
        : SettingGroup()
        , joinRecovery_(other.joinRecovery_)
        , gapAndErrorHandling_(other.gapAndErrorHandling_)
        , instrumentRecovery_(other.instrumentRecovery_)
        , marketRecovery_(other.marketRecovery_)
        , tcpRecovery_(other.tcpRecovery_)
    {
    }

    ~SessionSettings() {}

    JoinRecoveryOptions::Enum joinRecovery() const
    {
        return joinRecovery_;
    }

    SessionSettings& joinRecovery(JoinRecoveryOptions::Enum recovery)
    {
        group().controlAssignment("Join Recovery Strategy", joinRecovery_, recovery);
 
        return *this;
    }

    GapAndErrorHandlingOptions::Enum gapAndErrorHandling() const
    {
        return gapAndErrorHandling_;
    }

    SessionSettings& gapAndErrorHandling(GapAndErrorHandlingOptions::Enum handling)
    {
        group().controlAssignment("Gap And Error Handling Strategy", gapAndErrorHandling_, handling);
 
        return *this;
    }

    InstrumentRecoveryOptions::Enum instrumentRecovery() const
    {
        return instrumentRecovery_;
    }

    SessionSettings& instrumentRecovery(InstrumentRecoveryOptions::Enum recovery)
    {
        group().controlAssignment("Instrument Recovery Strategy", instrumentRecovery_, recovery);
 
        return *this;
    }

    MarketRecoveryOptions::Enum marketRecovery() const
    {
        return marketRecovery_;
    }

    SessionSettings& marketRecovery(MarketRecoveryOptions::Enum recovery)
    {
        group().controlAssignment("Market Recovery Strategy", marketRecovery_, recovery);
 
        return *this;
    }

    const TcpRecoverySessionSettings& tcpRecovery() const
    {
        return tcpRecovery_;
    }

    TcpRecoverySessionSettings& tcpRecovery()
    {
        return tcpRecovery_;
    }

    SessionSettings& operator=(const SessionSettings& other)
    {
        group().controlChange("Session Settings", &SessionSettings::assignNoControl, *this, other);
 
        return *this;
    }
 
protected:
    const SettingGroup& group() const
    {
        return *this;
    }

    void assignNoControl(const SessionSettings& other)
    {
        assignNoControlLegacy(other);
 
        tcpRecovery_.assignNoControl(other.tcpRecovery_);
    }
 
    void assignNoControlLegacy(const SessionSettings& other)
    {
        joinRecovery_ = other.joinRecovery_;
 
        gapAndErrorHandling_ = other.gapAndErrorHandling_;
 
        instrumentRecovery_ = other.instrumentRecovery_;
 
        marketRecovery_ = other.marketRecovery_;
    }
 
private:
    JoinRecoveryOptions::Enum joinRecovery_;
    GapAndErrorHandlingOptions::Enum gapAndErrorHandling_;
 
    InstrumentRecoveryOptions::Enum instrumentRecovery_;
    MarketRecoveryOptions::Enum marketRecovery_;
 
    TcpRecoverySessionSettings tcpRecovery_;
 
    friend ONIXS_CMEMDH_LTWT_CLASS_DECL(HandlerSettings);
    friend struct LegacyAssigner;
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string&, const SessionSettings&);

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


inline void setSessionToRecoverInstrumentsAccurately(SessionSettings& settings)
{
    settings.instrumentRecovery(InstrumentRecoveryOptions::Accurate);
}

inline void setSessionToRecoverInstrumentsFast(SessionSettings& settings)
{
    settings.instrumentRecovery(InstrumentRecoveryOptions::Fast);
}

inline void setSessionToJoinInPreopening(SessionSettings& settings)
{
    settings.joinRecovery(JoinRecoveryOptions::Disabled);
}

inline void setSessionToLateJoin(SessionSettings& settings)
{
    settings.joinRecovery(JoinRecoveryOptions::InstrumentsAndMarketState);
}

inline void setSessionToRecoverBothMboAndMbpBooks(SessionSettings& settings)
{
    settings.marketRecovery(MarketRecoveryOptions::BothMboAndMbp);
}

inline void setSessionToRecoverMboBooksOnly(SessionSettings& settings)
{
    settings.marketRecovery(MarketRecoveryOptions::MboOnly);
}

inline void setSessionToRecoverMbpBooksOnly(SessionSettings& settings)
{
    settings.marketRecovery(MarketRecoveryOptions::MbpOnly);
}

inline void setSessionToFullRecoverUponRealtimeIssues(SessionSettings& settings)
{
    settings.gapAndErrorHandling(GapAndErrorHandlingOptions::RecoverInstrumentsAndMarketState);
}

inline void setSessionToRecoverBooksUponRealtimeIssues(SessionSettings& settings)
{
    settings.gapAndErrorHandling(GapAndErrorHandlingOptions::RecoverMarketState);
}

inline void setSessionToContinueRealtimeProcessingUponIssues(SessionSettings& settings)
{
    settings.gapAndErrorHandling(GapAndErrorHandlingOptions::ContinueProcessing);
}
 
// Complex (one-call) setup.

inline void setSessionToAccuratePreopening(SessionSettings& settings)
{
    setSessionToRecoverInstrumentsAccurately(settings);
    setSessionToJoinInPreopening(settings);
    setSessionToRecoverBothMboAndMbpBooks(settings);
    setSessionToRecoverBooksUponRealtimeIssues(settings);
}

inline void setSessionToAccurateLateJoin(SessionSettings& settings)
{
    setSessionToRecoverInstrumentsAccurately(settings);
    setSessionToRecoverBothMboAndMbpBooks(settings);
    setSessionToLateJoin(settings);
    setSessionToRecoverBooksUponRealtimeIssues(settings);
}

inline void setSessionToNaturalRefresh(SessionSettings& settings)
{
    setSessionToJoinInPreopening(settings);
    setSessionToContinueRealtimeProcessingUponIssues(settings);
}
 
// Deprecated way of session setup.
 
#if !defined(ONIXS_CMEMDH_NO_DEPRECATED)

struct ONIXS_CMEMDH_LTWT AccuratePreopeningSession : SessionSettings
{
    AccuratePreopeningSession()
    {
        setSessionToAccuratePreopening(*this);
    }
};

struct ONIXS_CMEMDH_LTWT AccuratePreopeningMboSession : AccuratePreopeningSession
{
    AccuratePreopeningMboSession()
    {
        setSessionToAccuratePreopening(*this);
        setSessionToRecoverMboBooksOnly(*this);
    }
};

struct ONIXS_CMEMDH_LTWT AccuratePreopeningMbpSession : AccuratePreopeningSession
{
    AccuratePreopeningMbpSession()
    {
        setSessionToAccuratePreopening(*this);
        setSessionToRecoverMbpBooksOnly(*this);
    }
};

struct ONIXS_CMEMDH_LTWT AccurateLateJoinSession : SessionSettings
{
    AccurateLateJoinSession()
        : SessionSettings()
    {
        setSessionToAccurateLateJoin(*this);
    }
};

struct ONIXS_CMEMDH_LTWT AccurateLateJoinMboSession : AccurateLateJoinSession
{
    AccurateLateJoinMboSession()
    {
        setSessionToAccurateLateJoin(*this);
        setSessionToRecoverMboBooksOnly(*this);
    }
};

struct ONIXS_CMEMDH_LTWT AccurateLateJoinMbpSession : AccurateLateJoinSession
{
    AccurateLateJoinMbpSession()
    {
        setSessionToAccurateLateJoin(*this);
        setSessionToRecoverMbpBooksOnly(*this);
    }
};

struct ONIXS_CMEMDH_LTWT NaturalRefreshSession : SessionSettings
{
    NaturalRefreshSession()
        : SessionSettings()
    {
        setSessionToNaturalRefresh(*this);
    }
};
 
#endif // ONIXS_CMEMDH_NO_DEPRECATED
 
ONIXS_CMEMDH_NAMESPACE_END