Samples Namespace Reference

Namespaces
namespace	Default
namespace	details

Classes
struct	AppConfiguration
class	ArgCarriage
class	BenchmarkConfiguration
class	Book
class	BusSessionGatewayListener
class	ConfigurationBase
class	ConnectivityConfiguration
struct	CrossOrder
class	GatewayEmulatorThread
class	GatewayListener
class	Helper
struct	IdGenerator
class	InputLogFileConfiguration
class	Listener
class	LogonConfiguration
class	MainThreadAffinityConfiguration
struct	MessagePrinter
class	MySessionStorage
class	NetworkInterfaceConfiguration
class	OptionArgConverter
class	OptionArgConverter< const Char * >
class	OptionArgConverter< std::string >
class	Options
struct	Order
class	ReceivingThreadAffinityConfiguration
class	SessionSettings
class	Settings
class	SettingsConfiguration
struct	SignalHelper
class	StorageConfiguration
class	StorageConfigurationBase
class	TradingClient

Typedefs
typedef std::string	Option
typedef std::string	OptionArg
typedef std::vector< OptionArg >	OptionArgs
using	OrderPtr = std::shared_ptr<Order>
using	CrossOrderPtr = std::shared_ptr<CrossOrder>
using	NewOrderCrossRequestMsg = MessageHolder<NewOrderCrossRequest, getMaxMessageSize<NewOrderCrossRequest>(NewOrderCrossRequestMaxEntriesCount)>
using	NewOrderRequestMsg = MessageHolder<NewOrderRequest>
using	SecurityDefinitionRequestMsg = MessageHolder<SecurityDefinitionRequest>
using	CancelRequestMsg = MessageHolder<CancelRequest>
using	CancelReplaceRequestMsg = MessageHolder<CancelReplaceRequest>
using	OrderMassCancelRequestMsg = MessageHolder<OrderMassCancelRequest>
using	QuoteRequestMsg = MessageHolder<QuoteRequest>
using	QuoteCancelRequestMsg = MessageHolder<QuoteCancelRequest, getMaxMessageSize<QuoteCancelRequest>(QuoteCancelRequestMaxEntriesCount)>
using	MassQuoteRequestMsg = MessageHolder<MassQuoteRequest, getMaxMessageSize<MassQuoteRequest>(MassQuoteRequestMaxEntriesCount)>
template<class T>
using	hasTransactTime = typename details::hasTransactTimeImpl<cleanType<T>>
template<class T>
using	hasExecId = typename details::hasExecIdImpl<cleanType<T>>
template<class T>
using	hasExecType = typename details::hasExecTypeImpl<cleanType<T>>
template<class T>
using	hasLeavesQty = typename details::hasLeavesQtyImpl<cleanType<T>>
template<typename T>
using	OptionalRef = std::optional<std::shared_ptr<T>>

Functions
std::pair< std::unique_ptr< GatewayEmulatorThread< BusSessionGatewayListener > >, std::unique_ptr< GatewayEmulatorThread< GatewayListener > > >	createEmulator (const SessionSettings &settings, const ConnectivityConfiguration &cfg, bool tcpDirect=false)
template<typename T>
T	fromStr (const std::string &s)
std::shared_ptr< void >	setPriorityAndPolicy (Session *session=nullptr)
void	printBenchmarkSettings (std::ostream &o, size_t numberOfMessages, size_t intervalBetweenSending, size_t warmupInterval, SessionStorageType::Enum storageType)
std::unique_ptr< Session >	createSession (SessionType::Enum sessionType, SessionSettings settings, SessionListener *listener, SessionStorageType::Enum storageType)
std::unique_ptr< Session >	createSession (SessionReactor &stack, SessionType::Enum sessionType, SessionSettings settings, SessionListener *listener, SessionStorageType::Enum storageType)
std::unique_ptr< Session >	createSession (ServiceFactory &factory, SessionType::Enum sessionType, SessionSettings settings, SessionListener *listener, SessionStorageType::Enum storageType)
template<typename T, typename Stack>
std::future< T >	wait (Stack &stack, std::promise< T > &promise, std::chrono::seconds timeout=std::chrono::seconds{30})
template<typename T>
std::future< T >	wait (std::promise< T > &promise, std::chrono::seconds timeout=std::chrono::seconds{30})
BgwCredentials	receiveBgwCredentials (SessionSettings settings, std::string host, Port port)
void	throwBadOption (const Char *arg)
void	throwDuplicatedOption (const Char *option)
void	throwOptionArgConversionFailed (const Char *option)
template<typename T>
bool	fromStr (T &result, const std::string &s)
bool	fromStr (SessionStorageType::Enum &result, const std::string &s)
template<typename Value>
void	convertOptionArg (Value &value, const Char *option, const std::string &str)
void	throwBadOptionArgQty (const Char *option, size_t argQty, size_t minQty, size_t maxQty)
void	throwReqiredOptionArgMissing (const Char *option)
template<typename Value, typename Iterator>
bool	args (const Options &options, const Char *option, Iterator target, size_t minQty=0, size_t maxQty=static_cast< size_t >(-1))
template<typename Value>
Value	argOrDefault (const Options &options, const Char *option, const Value &defaultValue=Value())
template<typename Value, size_t Length>
const Value *	argOrDefault (const Options &options, const Char *option, Value(&defaultValue)[Length])
template<typename Value>
Value	requiredArg (const Options &options, const Char *option)
SessionSettings	fillSettings (const LogonConfiguration &logonCfg, const ConnectivityConfiguration &connCfg, const SettingsConfiguration &settingsCfg)
void	fillSettings (SessionSettings &settings, const StorageConfigurationBase &cfg)
template<typename Config>
void	fillStorageSettings (SessionSettings &settings, const Config &cfg, typename std::enable_if< std::is_base_of< StorageConfigurationBase, Config >::value, void * >::type=nullptr)
template<typename Config>
void	fillStorageSettings (SessionSettings &, const Config &, typename std::enable_if<!std::is_base_of< StorageConfigurationBase, Config >::value, void * >::type=nullptr)
template<typename Config>
void	fillBenchmarkSettings (SessionSettings &settings, const Config &, typename std::enable_if< std::is_base_of< BenchmarkConfiguration, Config >::value, void * >::type=nullptr)
template<typename Config>
void	fillBenchmarkSettings (SessionSettings &settings, const Config &, typename std::enable_if<!std::is_base_of< BenchmarkConfiguration, Config >::value, void * >::type=nullptr)
template<typename AppCfg>
SessionSettings	fillSettings (const AppCfg &cfg)
template<typename ... T>
void	ignoreUnusedVariableWarning (T &&...) noexcept
std::string	toStr (Order::PriceOptional value)
auto	print (OrderPtr order)
bool	activeOrder (const Order &order) noexcept
template<typename MsgType>
Timestamp	getTransactTime (MsgType &&msg, typename std::enable_if< hasTransactTime< MsgType >::value, void * >::type=nullptr)
template<typename MsgType>
Timestamp	getTransactTime (MsgType &&msg, typename std::enable_if<!hasTransactTime< MsgType >::value &&hasExecId< MsgType >::value, void * >::type=nullptr)
template<typename MsgType>
Timestamp	getTransactTime (MsgType &&, typename std::enable_if<!hasTransactTime< MsgType >::value &&!hasExecId< MsgType >::value, void * >::type=nullptr)
template<typename MsgType>
ExecTypeEnum	getOrdStatus (MsgType &&msg, ExecTypeEnum, typename std::enable_if< hasExecType< MsgType >::value, void * >::type=nullptr)
template<typename MsgType>
ExecTypeEnum	getOrdStatus (MsgType &&, ExecTypeEnum defaultValue, typename std::enable_if<!hasExecType< MsgType >::value, void * >::type=nullptr)
template<typename MsgType>
void	setOrdStatus (Order &order, MsgType &&msg, ExecTypeEnum defaultValue)
template<typename MsgType>
void	setLeavesQty (Order &order, MsgType &&msg, typename std::enable_if< hasLeavesQty< MsgType >::value, void * >::type=nullptr)
template<typename MsgType>
void	setLeavesQty (Order &, MsgType &&, typename std::enable_if<!hasLeavesQty< MsgType >::value, void * >::type=nullptr)
Decimal9	toPriceMantissa (Decimal value)
template<typename T>
T	parseUserInput (const std::string &userInput, typename std::enable_if< std::is_integral< T >::value, void * >::type=nullptr)
template<typename T>
T	parseUserInput (const std::string &userInput, typename std::enable_if< isScopedEnum< T >::value, void * >::type=nullptr)
template<typename T>
Decimal	parseUserInput (const std::string &userInput, typename std::enable_if< std::is_floating_point< T >::value, void * >::type=nullptr)
template<typename T>
T	parseUserInput (const std::string &userInput, typename std::enable_if< std::is_same< T, std::string >::value, void * >::type=nullptr)
template<typename T>
auto	toValueNamePair (T v, typename std::enable_if< isScopedEnum< T >::value, void * >::type=nullptr)
template<typename It>
auto	join (It first, It last, char delim, typename std::enable_if< isScopedEnum< typename It::value_type >::value, void * >::type=nullptr)

Variables
constexpr size_t	NewOrderCrossRequestMaxEntriesCount = 2
constexpr size_t	QuoteCancelRequestMaxEntriesCount = 1
constexpr size_t	MassQuoteRequestMaxEntriesCount = 2

Typedef Documentation

CancelReplaceRequestMsg

using CancelReplaceRequestMsg = MessageHolder<CancelReplaceRequest>

Definition at line 39 of file TradingClient.h.

CancelRequestMsg

using CancelRequestMsg = MessageHolder<CancelRequest>

Definition at line 38 of file TradingClient.h.

CrossOrderPtr

using CrossOrderPtr = std::shared_ptr<CrossOrder>

Definition at line 104 of file Order.h.

hasExecId

template<class T>

using hasExecId = typename details::hasExecIdImpl<cleanType<T>>

Definition at line 87 of file Utils.h.

hasExecType

template<class T>

using hasExecType = typename details::hasExecTypeImpl<cleanType<T>>

Definition at line 88 of file Utils.h.

hasLeavesQty

template<class T>

using hasLeavesQty = typename details::hasLeavesQtyImpl<cleanType<T>>

Definition at line 89 of file Utils.h.

hasTransactTime

template<class T>

using hasTransactTime = typename details::hasTransactTimeImpl<cleanType<T>>

Definition at line 86 of file Utils.h.

MassQuoteRequestMsg

using MassQuoteRequestMsg = MessageHolder<MassQuoteRequest, getMaxMessageSize<MassQuoteRequest>(MassQuoteRequestMaxEntriesCount)>

Definition at line 43 of file TradingClient.h.

NewOrderCrossRequestMsg

using NewOrderCrossRequestMsg = MessageHolder<NewOrderCrossRequest, getMaxMessageSize<NewOrderCrossRequest>(NewOrderCrossRequestMaxEntriesCount)>

Definition at line 35 of file TradingClient.h.

NewOrderRequestMsg

using NewOrderRequestMsg = MessageHolder<NewOrderRequest>

Definition at line 36 of file TradingClient.h.

Option

typedef std::string Option

Definition at line 33 of file Options.h.

OptionalRef

template<typename T>

using OptionalRef = std::optional<std::shared_ptr<T>>

Manages an optional contained reference.

Definition at line 224 of file Utils.h.

OptionArg

typedef std::string OptionArg

Definition at line 34 of file Options.h.

OptionArgs

typedef std::vector<OptionArg> OptionArgs

Definition at line 35 of file Options.h.

OrderMassCancelRequestMsg

using OrderMassCancelRequestMsg = MessageHolder<OrderMassCancelRequest>

Definition at line 40 of file TradingClient.h.

OrderPtr

using OrderPtr = std::shared_ptr<Order>

Definition at line 75 of file Order.h.

QuoteCancelRequestMsg

using QuoteCancelRequestMsg = MessageHolder<QuoteCancelRequest, getMaxMessageSize<QuoteCancelRequest>(QuoteCancelRequestMaxEntriesCount)>

Definition at line 42 of file TradingClient.h.

QuoteRequestMsg

using QuoteRequestMsg = MessageHolder<QuoteRequest>

Definition at line 41 of file TradingClient.h.

SecurityDefinitionRequestMsg

using SecurityDefinitionRequestMsg = MessageHolder<SecurityDefinitionRequest>

Definition at line 37 of file TradingClient.h.

Function Documentation

activeOrder()

bool activeOrder ( const Order & order )

noexcept

Definition at line 1053 of file TradingClient.cpp.

{
    return order.orderStatus_ == ExecTypeEnum::New || order.orderStatus_ == ExecTypeEnum::PartialFill || order.orderStatus_ == ExecTypeEnum::Replaced;
}

argOrDefault() [1/2]

template<typename Value>

Value argOrDefault ( const Options & options, const Char * option, const Value & defaultValue = Value() )

inline

Definition at line 375 of file Options.h.

{
    Value value = defaultValue;
 
    args<Value>(options, option, &value, 1, 1);
 
    return value;
}

argOrDefault() [2/2]

template<typename Value, size_t Length>

const Value * argOrDefault ( const Options & options, const Char * option, Value(&) defaultValue[Length] )

inline

Definition at line 385 of file Options.h.

{
    return argOrDefault<const Value*>(options, option, static_cast<const Value*>(defaultValue));
}

args()

template<typename Value, typename Iterator>

bool args ( const Options & options, const Char * option, Iterator target, size_t minQty = 0, size_t maxQty = static_cast<size_t>(-1) )

inline

Definition at line 345 of file Options.h.

{
    if (const OptionArgs* args = options.args(option))
    {
        const size_t argQty = args->size();
 
        if (minQty <= argQty && maxQty >= argQty)
        {
            const OptionArgConverter<Value> converter(option);
 
            std::transform(args->begin(), args->end(), target, converter);
 
            return true;
        }
        else
        {
            throwBadOptionArgQty(option, argQty, minQty, maxQty);
        }
    }
 
    return false;
}

convertOptionArg()

template<typename Value>

void convertOptionArg ( Value & value, const Char * option, const std::string & str )

inline

Definition at line 291 of file Options.h.

{
    const OptionArgConverter<Value> converter(option);
 
    value = converter(str);
}

createEmulator()

std::pair< std::unique_ptr< GatewayEmulatorThread< BusSessionGatewayListener > >, std::unique_ptr< GatewayEmulatorThread< GatewayListener > > > createEmulator ( const SessionSettings & settings, const ConnectivityConfiguration & cfg, bool tcpDirect = false )

inline

Definition at line 157 of file Emulator.h.

{
    if(cfg.useEmulator())
    {
#if !defined (_WIN32)
        if(tcpDirect)
            throw std::runtime_error("Emulator is not supported for TCPDirect.");
#endif
 
        std::clog << "!Emulator is used!" << std::endl;
 
        auto bgwSessionGatewayListener = std::make_unique<GatewayListener>();
        auto bgwSessionEmulatorThread = std::make_unique<GatewayEmulatorThread<GatewayListener>>(settings.licenseStores(), "127.0.0.1", 0, std::move(bgwSessionGatewayListener));
 
        auto busSessionGatewayListener = std::make_unique<BusSessionGatewayListener>(bgwSessionEmulatorThread->gateway().host(), bgwSessionEmulatorThread->gateway().port());
        auto busSessionEmulatorThread = std::make_unique<GatewayEmulatorThread<BusSessionGatewayListener>>(settings.licenseStores(), "127.0.0.1", cfg.port(), std::move(busSessionGatewayListener));
 
        return std::make_pair(std::move(busSessionEmulatorThread), std::move(bgwSessionEmulatorThread));
    }
 
    return {};
}

createSession() [1/3]

std::unique_ptr< Session > createSession ( ServiceFactory & factory, SessionType::Enum sessionType, SessionSettings settings, SessionListener * listener, SessionStorageType::Enum storageType )

inline

Definition at line 205 of file Helpers.h.

{
    return std::unique_ptr<Session>{new Session(factory, sessionType, settings, listener, storageType, nullptr, {})};
}

createSession() [2/3]

std::unique_ptr< Session > createSession ( SessionReactor & stack, SessionType::Enum sessionType, SessionSettings settings, SessionListener * listener, SessionStorageType::Enum storageType )

inline

Definition at line 199 of file Helpers.h.

{
    return std::unique_ptr<Session>{new Session(stack, sessionType, settings, listener, storageType, nullptr, {})};
}

createSession() [3/3]

std::unique_ptr< Session > createSession ( SessionType::Enum sessionType, SessionSettings settings, SessionListener * listener, SessionStorageType::Enum storageType )

inline

Definition at line 193 of file Helpers.h.

{
    return std::unique_ptr<Session>{new Session(sessionType, settings, listener, storageType, nullptr, {})};
}

fillBenchmarkSettings() [1/2]

template<typename Config>

void fillBenchmarkSettings	(	SessionSettings &	settings,
		const Config &	,
		typename std::enable_if< std::is_base_of< BenchmarkConfiguration, Config >::value, void * >::type	= nullptr )

Definition at line 83 of file Settings.h.

{
    if(settings.useTLS())
    {
        std::cerr << "Please disable TLS for benchmarking." << std::endl;
        exit(1);
    }
 
    settings.logLevel(LogLevel::Error);
    settings.loggerOptions(LogSettings::TraceToFile);
}

fillBenchmarkSettings() [2/2]

template<typename Config>

void fillBenchmarkSettings	(	SessionSettings &	settings,
		const Config &	,
		typename std::enable_if<!std::is_base_of< BenchmarkConfiguration, Config >::value, void * >::type	= nullptr )

Definition at line 96 of file Settings.h.

{
    settings.logLevel(LogLevel::Debug);
}

fillSettings() [1/3]

template<typename AppCfg>

SessionSettings fillSettings

(

const AppCfg &

cfg

)

Definition at line 102 of file Settings.h.

{
    auto settings = fillSettings(cfg, cfg, cfg);
    fillStorageSettings(settings, cfg);
    fillBenchmarkSettings(settings, cfg);
    return settings;
}

fillSettings() [2/3]

SessionSettings fillSettings ( const LogonConfiguration & logonCfg, const ConnectivityConfiguration & connCfg, const SettingsConfiguration & settingsCfg )

inline

Definition at line 32 of file Settings.h.

{
    SessionSettings settings;
 
    const auto settingsFilename = settingsCfg.settingsFile();
 
    if (ONIXS_ICEBOE_NAMESPACE::Filesystem::exist(settingsFilename))
    {
        settings.load(settingsFilename);
    }
    else
    {
        settings
            .licenseStore("../../license")
            .userId(logonCfg.userId())
            .clientId(logonCfg.clientId())
            .rawData(logonCfg.password());
    }
 
    if(connCfg.useEmulator())
        settings.keepAliveInterval(5).reconnectAttempts(0);
 
    settings.useTLS(connCfg.useTLS());
 
    if(settings.useTLS())
        std::cerr << "TLS connection is selected." << std::endl;
 
    return settings;
}

fillSettings() [3/3]

void fillSettings ( SessionSettings & settings, const StorageConfigurationBase & cfg )

inline

Definition at line 64 of file Settings.h.

{
    const auto storageType = cfg.storage();
 
    if(storageType == SessionStorageType::AsyncFileBased)
        settings.asyncFileBasedStorageThreadAffinity({cfg.storageAffinity()});
}

fillStorageSettings() [1/2]

template<typename Config>

void fillStorageSettings	(	SessionSettings &	,
		const Config &	,
		typename std::enable_if<!std::is_base_of< StorageConfigurationBase, Config >::value, void * >::type	= nullptr )

Definition at line 79 of file Settings.h.

{}

fillStorageSettings() [2/2]

template<typename Config>

void fillStorageSettings	(	SessionSettings &	settings,
		const Config &	cfg,
		typename std::enable_if< std::is_base_of< StorageConfigurationBase, Config >::value, void * >::type	= nullptr )

Definition at line 73 of file Settings.h.

{
     fillSettings(settings, cfg);
}

fromStr() [1/3]

template<typename T>

T fromStr

(

const std::string &

s

)

Definition at line 142 of file Helpers.h.

{
    std::istringstream ss(s);
    T result = T();
    ss >> result;
    return result;
}

fromStr() [2/3]

bool fromStr ( SessionStorageType::Enum & result, const std::string & s )

inline

Definition at line 230 of file Options.h.

{
    try
    {
        result = SessionStorageType::parse(s);
        return true;
    }
    catch(...)
    {
        return false;
    }
}

fromStr() [3/3]

template<typename T>

bool fromStr	(	T &	result,
		const std::string &	s )

Definition at line 224 of file Options.h.

{
    return Messaging::fromStr(result, s.data(), s.size());
}

getOrdStatus() [1/2]

template<typename MsgType>

ExecTypeEnum getOrdStatus	(	MsgType &&	,
		ExecTypeEnum	defaultValue,
		typename std::enable_if<!hasExecType< MsgType >::value, void * >::type	= nullptr )

Definition at line 116 of file Utils.h.

{
    return defaultValue;
}

getOrdStatus() [2/2]

template<typename MsgType>

ExecTypeEnum getOrdStatus	(	MsgType &&	msg,
		ExecTypeEnum	,
		typename std::enable_if< hasExecType< MsgType >::value, void * >::type	= nullptr )

Definition at line 110 of file Utils.h.

{
    return msg.execType();
}

getTransactTime() [1/3]

template<typename MsgType>

Timestamp getTransactTime	(	MsgType &&	,
		typename std::enable_if<!hasTransactTime< MsgType >::value &&!hasExecId< MsgType >::value, void * >::type	= nullptr )

Definition at line 104 of file Utils.h.

{
    return Timestamp{};
}

getTransactTime() [2/3]

template<typename MsgType>

Timestamp getTransactTime	(	MsgType &&	msg,
		typename std::enable_if< hasTransactTime< MsgType >::value, void * >::type	= nullptr )

Definition at line 92 of file Utils.h.

{
    return msg.transactTime();
}

getTransactTime() [3/3]

template<typename MsgType>

Timestamp getTransactTime	(	MsgType &&	msg,
		typename std::enable_if<!hasTransactTime< MsgType >::value &&hasExecId< MsgType >::value, void * >::type	= nullptr )

Definition at line 98 of file Utils.h.

{
    return msg.execId().transactTime();
}

ignoreUnusedVariableWarning()

template<typename ... T>

void ignoreUnusedVariableWarning ( T && ... )

noexcept

Definition at line 23 of file Tools.h.

{}

join()

template<typename It>

auto join ( It first, It last, char delim, typename std::enable_if< isScopedEnum< typename It::value_type >::value, void * >::type = nullptr )

inline

Definition at line 208 of file Utils.h.

{
    if (first == last)
        return std::string{};
 
    std::ostringstream oss;
    oss << toValueNamePair(*first);
    ++first;
    for (; first != last; ++first)
        oss << delim << toValueNamePair(*first);
 
    return oss.str();
}

parseUserInput() [1/4]

template<typename T>

T parseUserInput	(	const std::string &	userInput,
		typename std::enable_if< isScopedEnum< T >::value, void * >::type	= nullptr )

Definition at line 157 of file Utils.h.

{
    std::istringstream ss{userInput};
    ss >> std::ws;
 
    using Wide =
            typename std::conditional<
            std::is_same<typename underlyingType<T>::type, char>::value,
                char,
                typename std::conditional<std::is_signed<T>::value,
                    long long,
                    unsigned long long>::type>::type;
 
    Wide converted{};
 
    if (!(ss >> converted))
        throw std::invalid_argument("Invalid user input: '" + userInput + "'");
 
    const auto enumerated = static_cast<T>(static_cast<typename underlyingType<T>::type>(converted));
 
    if(ONIXS_ICEBOE_MESSAGING_NAMESPACE::toStr(enumerated).find("UNKNOWN_VALUE") != std::string::npos)
        throw std::invalid_argument("Invalid user input: '" + userInput + "'");
 
    return enumerated;
}

parseUserInput() [2/4]

template<typename T>

Decimal parseUserInput	(	const std::string &	userInput,
		typename std::enable_if< std::is_floating_point< T >::value, void * >::type	= nullptr )

Definition at line 184 of file Utils.h.

{
    Decimal value;
 
    if(fromStr(value, userInput))
        return value;
 
    throw std::invalid_argument("Invalid user input: '" + userInput + "'");
}

parseUserInput() [3/4]

template<typename T>

T parseUserInput	(	const std::string &	userInput,
		typename std::enable_if< std::is_integral< T >::value, void * >::type	= nullptr )

Definition at line 142 of file Utils.h.

{
    std::istringstream ss{userInput};
    ss >> std::ws;
 
    using Wide = typename std::conditional<std::is_signed<T>::value, long long, unsigned long long>::type;
    Wide converted{};
 
    if (!(ss >> converted))
        throw std::invalid_argument("Invalid user input: '" + userInput + "'");
 
    return static_cast<T>(converted);
}

parseUserInput() [4/4]

template<typename T>

T parseUserInput	(	const std::string &	userInput,
		typename std::enable_if< std::is_same< T, std::string >::value, void * >::type	= nullptr )

Definition at line 195 of file Utils.h.

{
    return userInput;
}

print()

auto print ( OrderPtr order )

inline

Definition at line 77 of file Order.h.

{
    return order ? order->toString() : toStr(nullOpt);
}

printBenchmarkSettings()

void printBenchmarkSettings ( std::ostream & o, size_t numberOfMessages, size_t intervalBetweenSending, size_t warmupInterval, SessionStorageType::Enum storageType )

inline

Definition at line 182 of file Helpers.h.

{
    o << "\n\n\n****" << std::endl;
 
    o << std::endl << "Benchmark Parameters: numberOfMessages=" << numberOfMessages << "; intervalBetweenSending(μSec)=" << intervalBetweenSending
        << "; warmupInterval(μSec)=" << warmupInterval
        << "; StorageType=" << SessionStorageType::toString(storageType) << '.' << std::endl;
}

receiveBgwCredentials()

BgwCredentials receiveBgwCredentials ( SessionSettings settings, std::string host, Port port )

inline

Definition at line 264 of file Listener.h.

{
    settings.threadingModel(ThreadingModel::Dedicated);
 
    Listener listener;
 
    // Create an instance of a `BUS` session.
    BusSession busSession(settings, &listener);
 
    // Connect.
    busSession.connect(host, port);
 
    const auto bgwCredentialsFuture = busSession.getBgwCredentialsAsync(settings.userId());
 
    const auto bgwCredentials = bgwCredentialsFuture.get();
 
    // Disconnect.
    busSession.disconnect();
 
    return bgwCredentials;
}

requiredArg()

template<typename Value>

Value requiredArg ( const Options & options, const Char * option )

inline

Definition at line 391 of file Options.h.

{
    const OptionArgs* args = options.args(option);
 
    if (nullptr == args || 1 != args->size())
    {
        throwReqiredOptionArgMissing(option);
    }
 
    const OptionArgConverter<Value> converter(option);
 
    return converter((*args)[0]);
}

setLeavesQty() [1/2]

template<typename MsgType>

void setLeavesQty	(	Order &	,
		MsgType &&	,
		typename std::enable_if<!hasLeavesQty< MsgType >::value, void * >::type	= nullptr )

Definition at line 134 of file Utils.h.

{}

setLeavesQty() [2/2]

template<typename MsgType>

void setLeavesQty	(	Order &	order,
		MsgType &&	msg,
		typename std::enable_if< hasLeavesQty< MsgType >::value, void * >::type	= nullptr )

Definition at line 128 of file Utils.h.

{
    order.leavesQty_ = msg.leavesQty();
}

setOrdStatus()

template<typename MsgType>

void setOrdStatus	(	Order &	order,
		MsgType &&	msg,
		ExecTypeEnum	defaultValue )

Definition at line 122 of file Utils.h.

{
    order.orderStatus_ = getOrdStatus(msg, defaultValue);
}

setPriorityAndPolicy()

std::shared_ptr< void > setPriorityAndPolicy ( Session * session = nullptr )

inline

Definition at line 150 of file Helpers.h.

{
#ifdef _WIN32
    ONIXS_ICEBOE_NAMESPACE::Threading::ThisThread::priority(THREAD_PRIORITY_ABOVE_NORMAL);
 
    if(session)
        session->receivingThreadPriority(THREAD_PRIORITY_ABOVE_NORMAL);
#else
    const int policy = SCHED_RR;
    try
    {
        Threading::ThisThread::policy(policy);
 
        if(session)
            session->receivingThreadPolicy(policy);
    }
    catch (const std::exception&)
    {
        std::cerr << "\nWARNING: Cannot change the scheduling policy to " << policy <<
             ", it requires root permissions, so you either have to be root or run it with sudo." << std::endl;
    }
#endif
 
    return std::shared_ptr<void>{nullptr, [](void*)
    {
#ifndef _WIN32
        ONIXS_ICEBOE_NAMESPACE::Threading::ThisThread::policy(SCHED_OTHER);
#endif
    }};
}

throwBadOption()

void throwBadOption ( const Char * arg )

inline

Definition at line 74 of file Options.h.

{
    assert(arg);
 
    std::string issue;
 
    issue += "The given argument [";
    issue += arg;
    issue += "] does not represent an option which must begin with the '--' prefix. ";
 
    throw std::runtime_error(issue);
}

throwBadOptionArgQty()

void throwBadOptionArgQty ( const Char * option, size_t argQty, size_t minQty, size_t maxQty )

inline

Definition at line 298 of file Options.h.

{
    assert(nullptr != option);
 
    std::string issue;
 
    issue += "Number of arguments for the option [";
 
    issue += option;
 
    issue += "] does not meet the requirements. "
             "It must be not less than ";
 
    toStr(issue, minQty);
 
    if (maxQty != static_cast<size_t>(-1))
    {
        issue += " and not greater than ";
 
        toStr(issue, maxQty);
    }
 
    issue += ". Meanwhile, the actual number is ";
 
    toStr(issue, argQty);
 
    issue += ". ";
 
    throw std::runtime_error(issue);
}

throwDuplicatedOption()

void throwDuplicatedOption ( const Char * option )

inline

Definition at line 87 of file Options.h.

{
    std::string issue;
 
    issue += "The given option [";
    issue += option;
    issue += "] is defined twice in the argument list. ";
 
    throw std::runtime_error(issue);
}

throwOptionArgConversionFailed()

void throwOptionArgConversionFailed ( const Char * option )

inline

Definition at line 209 of file Options.h.

{
    assert(nullptr != option);
 
    std::string issue;
 
    issue += "Value for the option [";
    issue += option;
    issue += "] is not recognized. Run application help for information on valid values for the option. ";
 
    throw std::runtime_error(issue);
}

throwReqiredOptionArgMissing()

void throwReqiredOptionArgMissing ( const Char * option )

inline

Definition at line 329 of file Options.h.

{
    assert(nullptr != option);
 
    std::string issue;
 
    issue += "The required option [";
 
    issue += option;
 
    issue += "] or its argument is missing. ";
 
    throw std::runtime_error(issue);
}

toPriceMantissa()

Decimal9 toPriceMantissa ( Decimal value )

inline

Definition at line 136 of file Utils.h.

{
    return quantize(value, -9).mantissa();
}

toStr()

std::string toStr

(

Order::PriceOptional

value

)

Definition at line 34 of file Order.cpp.

{
    return (value != nullOpt) ? toStr(Decimal{*value, -9}) : toStr(nullOpt);
}

toValueNamePair()

template<typename T>

auto toValueNamePair	(	T	v,
		typename std::enable_if< isScopedEnum< T >::value, void * >::type	= nullptr )

Definition at line 202 of file Utils.h.

{
    return toStr(toUnderlying(v)) + "-" + toStr(v);
}

wait() [1/2]

template<typename T, typename Stack>

std::future< T > wait	(	Stack &	stack,
		std::promise< T > &	promise,
		std::chrono::seconds	timeout = std::chrono::seconds{30} )

Definition at line 227 of file Listener.h.

                                                                                                   {30})
{
    auto future = promise.get_future();
 
    const auto deadline = std::chrono::steady_clock::now() + timeout;
    std::uint32_t spins = 0;
 
    for (;;)
    {
        stack.dispatchEvents();
 
        if (future.wait_for(std::chrono::nanoseconds{0}) == std::future_status::ready)
            return future;
 
        if ((++spins & 0xFFu) == 0)  // every 256 iterations
        {
            if (std::chrono::steady_clock::now() >= deadline)
            {
                promise.set_exception(std::make_exception_ptr(std::runtime_error("Operation timed out.")));
                return future;
            }
        }
    }
}

wait() [2/2]

template<typename T>

std::future< T > wait	(	std::promise< T > &	promise,
		std::chrono::seconds	timeout = std::chrono::seconds{30} )

Definition at line 253 of file Listener.h.

                                                                                     {30})
{
    auto future = promise.get_future();
 
    if(future.wait_for(timeout) != std::future_status::ready)
        promise.set_exception(std::make_exception_ptr(std::runtime_error("Operation timed out.")));
 
    return future;
}

Variable Documentation

MassQuoteRequestMaxEntriesCount

size_t MassQuoteRequestMaxEntriesCount = 2

constexpr

Definition at line 33 of file TradingClient.h.

NewOrderCrossRequestMaxEntriesCount

size_t NewOrderCrossRequestMaxEntriesCount = 2

constexpr

Definition at line 31 of file TradingClient.h.

QuoteCancelRequestMaxEntriesCount

size_t QuoteCancelRequestMaxEntriesCount = 1

constexpr

Definition at line 32 of file TradingClient.h.