437 lines
11 KiB
C++
437 lines
11 KiB
C++
// 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/Integral.h>
|
|
|
|
ONIXS_CMEMDH_NAMESPACE_BEGIN
|
|
|
|
/// Defines type of recovery to be done
|
|
/// by Handler at the time it joins market.
|
|
ONIXS_CMEMDH_LTWT_STRUCT
|
|
JoinRecoveryOptions
|
|
{
|
|
/// Integral type serving as
|
|
/// basement for given enumeration.
|
|
typedef UInt32 Base;
|
|
|
|
/// Defines type of recovery to be done
|
|
/// by Handler while it joins market.
|
|
enum Enum
|
|
{
|
|
/// No recovery is to be done at join time.
|
|
/// Handler will switch to real-time data
|
|
/// processing immediately.
|
|
Disabled,
|
|
|
|
/// Instructs Handler to recover instruments before
|
|
/// switching to real-time (incremental data) processing.
|
|
Instruments,
|
|
|
|
/// Instructs Handler to perform full recovery (both instruments
|
|
/// and market state (books, last trades, statistics, etc))
|
|
/// before switching to real-time (incremental) data processing.
|
|
InstrumentsAndMarketState
|
|
};
|
|
};
|
|
|
|
/// Serializes join recovery option.
|
|
ONIXS_CMEMDH_EXPORTED
|
|
void
|
|
toStr(
|
|
std::string&,
|
|
JoinRecoveryOptions::Enum);
|
|
|
|
/// Serializes join recovery option.
|
|
inline
|
|
std::string
|
|
toStr(
|
|
JoinRecoveryOptions::Enum recovery)
|
|
{
|
|
std::string str;
|
|
|
|
toStr(str, recovery);
|
|
|
|
return str;
|
|
}
|
|
|
|
/// Defines the way Handler has to handle
|
|
/// gap in real-time (incremental) data.
|
|
ONIXS_CMEMDH_LTWT_STRUCT
|
|
GapAndErrorHandlingOptions
|
|
{
|
|
/// Integral type serving as
|
|
/// basement for given enumeration.
|
|
typedef UInt32 Base;
|
|
|
|
/// Defines the way Handler has to handle
|
|
/// gap in real-time (incremental) data.
|
|
enum Enum
|
|
{
|
|
/// Handler recovers market state from snapshots.
|
|
RecoverMarketState,
|
|
|
|
/// Handler recovers instruments and market state afterwards.
|
|
RecoverInstrumentsAndMarketState,
|
|
|
|
/// Handler continues processing of real-time market data.
|
|
ContinueProcessing
|
|
};
|
|
};
|
|
|
|
/// Serializes gap and error handling option.
|
|
ONIXS_CMEMDH_EXPORTED
|
|
void
|
|
toStr(
|
|
std::string&,
|
|
GapAndErrorHandlingOptions::Enum);
|
|
|
|
/// Serializes gap and error handling option.
|
|
inline
|
|
std::string
|
|
toStr(
|
|
GapAndErrorHandlingOptions::Enum handling)
|
|
{
|
|
std::string str;
|
|
|
|
toStr(str, handling);
|
|
|
|
return str;
|
|
}
|
|
|
|
/// Defines market state recovery options.
|
|
ONIXS_CMEMDH_LTWT_STRUCT
|
|
MarketRecoveryOptions
|
|
{
|
|
/// Integral type serving as
|
|
/// basement for given enumeration.
|
|
typedef UInt32 Base;
|
|
|
|
enum Enum
|
|
{
|
|
/// Only market by price books will be
|
|
/// recovered during market state recovery.
|
|
MbpOnly,
|
|
|
|
/// Only market by order books will be
|
|
/// recovered during market state recovery.
|
|
MboOnly,
|
|
|
|
/// Both market by price and market by order
|
|
/// books will be recovered during market
|
|
/// state recovery.
|
|
BothMboAndMbp
|
|
};
|
|
};
|
|
|
|
/// Serializes market recovery option.
|
|
ONIXS_CMEMDH_EXPORTED
|
|
void
|
|
toStr(
|
|
std::string&,
|
|
MarketRecoveryOptions::Enum);
|
|
|
|
/// Serializes market recovery option.
|
|
inline
|
|
std::string
|
|
toStr(
|
|
MarketRecoveryOptions::Enum option)
|
|
{
|
|
std::string str;
|
|
|
|
toStr(str, option);
|
|
|
|
return str;
|
|
}
|
|
|
|
/// Set of parameters affecting Handler's behavior
|
|
/// when market data processing session is spawned.
|
|
ONIXS_CMEMDH_LTWT_CLASS SessionSettings
|
|
{
|
|
JoinRecoveryOptions::Enum joinRecovery_;
|
|
GapAndErrorHandlingOptions::Enum gapAndErrorHandling_;
|
|
MarketRecoveryOptions::Enum marketRecovery_;
|
|
|
|
public:
|
|
/// Initializes parameters with default values.
|
|
SessionSettings()
|
|
: joinRecovery_(
|
|
JoinRecoveryOptions::
|
|
InstrumentsAndMarketState)
|
|
, gapAndErrorHandling_(
|
|
GapAndErrorHandlingOptions::
|
|
RecoverMarketState)
|
|
, marketRecovery_(
|
|
MarketRecoveryOptions::BothMboAndMbp)
|
|
{
|
|
}
|
|
|
|
/// Cleans everything up.
|
|
~SessionSettings()
|
|
{
|
|
}
|
|
|
|
/// Defines aspects of recovery to be done at market join stage.
|
|
///
|
|
/// @note Default value is JoinRecovery::InstrumentsAndMarket.
|
|
JoinRecoveryOptions::Enum
|
|
joinRecovery() const
|
|
{
|
|
return joinRecovery_;
|
|
}
|
|
|
|
/// Defines aspects of recovery to be done at market join stage.
|
|
void
|
|
joinRecovery(
|
|
JoinRecoveryOptions::Enum recovery)
|
|
{
|
|
joinRecovery_ = recovery;
|
|
}
|
|
|
|
/// Defines what Handler should do in case
|
|
/// of gap in real-time (incremental) data.
|
|
///
|
|
/// @note Default value is GapAndErrorHandling::RecoverMarketState.
|
|
GapAndErrorHandlingOptions::Enum
|
|
gapAndErrorHandling() const
|
|
{
|
|
return gapAndErrorHandling_;
|
|
}
|
|
|
|
/// Defines what Handler should do in case
|
|
/// of gap in real-time (incremental) data.
|
|
void
|
|
gapAndErrorHandling(
|
|
GapAndErrorHandlingOptions::Enum handling)
|
|
{
|
|
gapAndErrorHandling_ = handling;
|
|
}
|
|
|
|
/// Defines selected market recovery options.
|
|
///
|
|
/// @note Default value is MarketRecovery::BothMboAndMbp.
|
|
MarketRecoveryOptions::Enum
|
|
marketRecovery() const
|
|
{
|
|
return marketRecovery_;
|
|
}
|
|
|
|
/// Defines market recovery options.
|
|
void
|
|
marketRecovery(
|
|
MarketRecoveryOptions::Enum recovery)
|
|
{
|
|
marketRecovery_ = recovery;
|
|
}
|
|
};
|
|
|
|
/// Serializes market data processing session settings.
|
|
ONIXS_CMEMDH_EXPORTED
|
|
void
|
|
toStr(
|
|
std::string&,
|
|
const SessionSettings&);
|
|
|
|
/// Serializes market data processing session settings.
|
|
inline
|
|
std::string
|
|
toStr(
|
|
const SessionSettings& settings)
|
|
{
|
|
std::string str;
|
|
|
|
toStr(str, settings);
|
|
|
|
return str;
|
|
}
|
|
|
|
//
|
|
|
|
/// Settings for session with accurate book
|
|
/// maintenance and considering market data
|
|
/// processing is started from the beginning
|
|
/// of weekly session.
|
|
ONIXS_CMEMDH_LTWT_CLASS
|
|
AccuratePreopeningSession
|
|
: public SessionSettings
|
|
{
|
|
using
|
|
SessionSettings::
|
|
joinRecovery;
|
|
|
|
using
|
|
SessionSettings::
|
|
gapAndErrorHandling;
|
|
|
|
public:
|
|
/// Configures session settings
|
|
/// according to specialization.
|
|
AccuratePreopeningSession()
|
|
{
|
|
joinRecovery(
|
|
JoinRecoveryOptions::
|
|
Disabled);
|
|
|
|
gapAndErrorHandling(
|
|
GapAndErrorHandlingOptions::
|
|
RecoverMarketState);
|
|
}
|
|
};
|
|
|
|
/// Settings for session with accurate book maintenance
|
|
/// and considering market data processing is started
|
|
/// from the beginning of weekly session. Market recovery
|
|
/// is limited to recovery market by order books only.
|
|
ONIXS_CMEMDH_LTWT_STRUCT
|
|
AccuratePreopeningMboSession
|
|
: AccuratePreopeningSession
|
|
{
|
|
/// Configures session settings
|
|
/// according to specialization.
|
|
AccuratePreopeningMboSession()
|
|
{
|
|
marketRecovery(
|
|
MarketRecoveryOptions::
|
|
MboOnly);
|
|
}
|
|
};
|
|
|
|
/// Settings for session with accurate book maintenance
|
|
/// and considering market data processing is started
|
|
/// from the beginning of weekly session. Market recovery
|
|
/// is limited to recovery market by price books only.
|
|
ONIXS_CMEMDH_LTWT_STRUCT
|
|
AccuratePreopeningMbpSession
|
|
: AccuratePreopeningSession
|
|
{
|
|
/// Configures session settings
|
|
/// according to specialization.
|
|
AccuratePreopeningMbpSession()
|
|
{
|
|
marketRecovery(
|
|
MarketRecoveryOptions::
|
|
MbpOnly);
|
|
}
|
|
};
|
|
|
|
/// Settings for session with accurate book
|
|
/// maintenance and considering market data
|
|
/// processing is started at the middle of
|
|
/// weekly session (late join).
|
|
ONIXS_CMEMDH_LTWT_CLASS
|
|
AccurateLateJoinSession
|
|
: public SessionSettings
|
|
{
|
|
using
|
|
SessionSettings::
|
|
joinRecovery;
|
|
|
|
using
|
|
SessionSettings::
|
|
gapAndErrorHandling;
|
|
|
|
public:
|
|
/// Configures session settings
|
|
/// according to specialization.
|
|
AccurateLateJoinSession()
|
|
: SessionSettings()
|
|
{
|
|
joinRecovery(
|
|
JoinRecoveryOptions::
|
|
InstrumentsAndMarketState);
|
|
|
|
gapAndErrorHandling(
|
|
GapAndErrorHandlingOptions::
|
|
RecoverMarketState);
|
|
}
|
|
};
|
|
|
|
/// Settings for session with accurate book maintenance
|
|
/// and considering market data processing is started at
|
|
/// the middle of weekly session (late join). Market recovery
|
|
/// is limited to recover market by order books only.
|
|
ONIXS_CMEMDH_LTWT_STRUCT
|
|
AccurateLateJoinMboSession
|
|
: AccurateLateJoinSession
|
|
{
|
|
/// Configures session settings
|
|
/// according to specialization.
|
|
AccurateLateJoinMboSession()
|
|
{
|
|
marketRecovery(
|
|
MarketRecoveryOptions::
|
|
MboOnly);
|
|
}
|
|
};
|
|
|
|
/// Settings for session with accurate book maintenance
|
|
/// and considering market data processing is started at
|
|
/// the middle of weekly session (late join). Market recovery
|
|
/// is limited to recover market by price books only.
|
|
ONIXS_CMEMDH_LTWT_STRUCT
|
|
AccurateLateJoinMbpSession
|
|
: AccurateLateJoinSession
|
|
{
|
|
/// Configures session settings
|
|
/// according to specialization.
|
|
AccurateLateJoinMbpSession()
|
|
{
|
|
marketRecovery(
|
|
MarketRecoveryOptions::
|
|
MbpOnly);
|
|
}
|
|
};
|
|
|
|
/// Configures session settings to maintain
|
|
/// order books using natural refresh. Startup
|
|
/// recovery is not performed and thus only
|
|
/// real-time processing takes place.
|
|
ONIXS_CMEMDH_LTWT_CLASS
|
|
NaturalRefreshSession
|
|
: public SessionSettings
|
|
{
|
|
using
|
|
SessionSettings::
|
|
joinRecovery;
|
|
|
|
using
|
|
SessionSettings::
|
|
gapAndErrorHandling;
|
|
|
|
public:
|
|
/// Configures session settings
|
|
/// according to specialization.
|
|
NaturalRefreshSession()
|
|
: SessionSettings()
|
|
{
|
|
joinRecovery(
|
|
JoinRecoveryOptions::Disabled);
|
|
|
|
gapAndErrorHandling(
|
|
GapAndErrorHandlingOptions::
|
|
ContinueProcessing);
|
|
}
|
|
};
|
|
|
|
ONIXS_CMEMDH_NAMESPACE_END
|