Helpers.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 <OnixS/ICE/BOE/IceBoe.h>
 
#include "../Settings/Defaults.h"
#include "../Common/Options.h"
 
#include <string>
#include <sstream>
#include <iostream>
#include <cstdio>
#include <fstream>
 
#include <thread>
#include <future>
#include <functional>
#include <chrono>
 
namespace Samples {
using namespace ONIXS_ICEBOE_MESSAGING_NAMESPACE;
 
struct IdGenerator
{
    static int32_t newId()
    {
        constexpr int64_t limit = (std::numeric_limits<int32_t>::max)();
        const uint64_t ticks = static_cast<uint64_t>(UtcWatch::now().sinceEpoch());
        return static_cast<int32_t>((splitmix64(ticks) % limit) + 1);
    }
 
private:
    static uint64_t splitmix64(uint64_t x) noexcept
    {
        x ^= 0x726f62696eULL;
        x += 0x9e3779b97f4a7c15ULL;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9ULL;
        x = (x ^ (x >> 27)) * 0x94d049bb133111ebULL;
        x ^= (x >> 31);
        return x;
    }
};
 
class Helper
{
public:
    static MessageHolder<IPRequest> createIpRequest(int clientId, const std::string& userId)
    {
        MessageHolder<IPRequest> request;
 
        request->clientId(clientId);
 
        auto users = request->users(1);
        users[0].userId(userId);
 
        return request;
    }
 
    static MessageHolder<TraderLogonRequest> createTraderLogonRequest(const std::string& traderId, const std::string& traderPwd)
    {
        MessageHolder<TraderLogonRequest> request;
 
        request->originatorUserId(traderId);
        request->directElectronicAccess(BooleanEnum::True);
        request->tradingCapacity(TradingCapacityEnum::DEAL);
        request->liquidityProvision(BooleanEnum::True);
        request->commodityDerivIndicator(BooleanEnum::False);
        request->investmentDecision(87657);
        request->executionDecision(87657);
        request->clientIdCode(nullOpt);
        request->mifidId(nullOpt);
        request->rawData(traderPwd);
 
        return request;
    }
 
    static MessageHolder<TraderLogoutRequest> createTraderLogoutRequest(const std::string& traderId)
    {
        MessageHolder<TraderLogoutRequest> request;
 
        request->originatorUserId(traderId);
 
        return request;
    }
 
    static MessageHolder<NewOrderRequest> createOrder(const std::string& traderId)
    {
        MessageHolder<NewOrderRequest> request;
 
        request->originatorUserId(traderId);
 
        request->directElectronicAccess(nullOpt);
        request->tradingCapacity(nullOpt);
        request->liquidityProvision(nullOpt);
        request->commodityDerivIndicator(nullOpt);
        request->investmentDecision(nullOpt);
        request->executionDecision(nullOpt);
        request->clientIdCode(nullOpt);
        request->customerAccountRefId(nullOpt);
 
        request->side(SideEnum::Buy);
        request->ordType(OrderTypeEnum::Market);
        request->timeInForce(TimeInForceEnum::Day);
 
        request->price(nullOpt);
        request->orderQty(1000000000);
        request->symbol(5884693);
        request->clOrdId(IdGenerator::newId());
 
 
        request->onBehalfOfSubId("DAU|DAU");
        request->onBehalfOfLocationId("DAU|DAU");
        request->onBehalfOfCompId("DAU|DAU");
        request->clearingFirm(649);
        request->clearingAccount("TEST");
        request->selfMatchPreventionId(nullOpt);
        request->mifidId(10);
 
        return request;
    }
};
 
template <typename T>
T fromStr(const std::string & s)
{
    std::istringstream ss(s);
    T result = T();
    ss >> result;
    return result;
}
 
inline std::shared_ptr<void> setPriorityAndPolicy(Session* session = nullptr)
{
#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
    }};
}
 
inline
void printBenchmarkSettings(
        std::ostream& o, size_t numberOfMessages, size_t intervalBetweenSending, size_t warmupInterval, SessionStorageType::Enum storageType)
{
    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;
}
 
inline
std::unique_ptr<Session> createSession(SessionType::Enum sessionType, SessionSettings settings, SessionListener* listener, SessionStorageType::Enum storageType)
{
    return std::unique_ptr<Session>{new Session(sessionType, settings, listener, storageType, nullptr, {})};
}
 
inline
std::unique_ptr<Session> createSession(SessionReactor & stack, SessionType::Enum sessionType, SessionSettings settings, SessionListener* listener, SessionStorageType::Enum storageType)
{
    return std::unique_ptr<Session>{new Session(stack, sessionType, settings, listener, storageType, nullptr, {})};
}
 
inline
std::unique_ptr<Session> createSession(ServiceFactory & factory, SessionType::Enum sessionType, SessionSettings settings, SessionListener* listener, SessionStorageType::Enum storageType)
{
    return std::unique_ptr<Session>{new Session(factory, sessionType, settings, listener, storageType, nullptr, {})};
}
 
}