Utils.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/ABI.h>
#include <OnixS/ICE/BOE/messaging/Utils.h>
#include <OnixS/ICE/BOE/messaging/Messages.h>
 
#include "Order.h"
 
#include <istream>
#include <sstream>
 
#ifdef ONIXS_ICEBOE_CXX17
#  include <optional>
#endif
 
namespace Samples {
 
using namespace ONIXS_ICEBOE_NAMESPACE;
using namespace ONIXS_ICEBOE_MESSAGING_NAMESPACE;
 
namespace details {
 
template<typename T>
struct hasTransactTimeImpl
{
    template<typename U, Timestamp (U::*)() const> struct SFINAE {};
    template<typename U> static char test(SFINAE<U, &U::transactTime>*);
 
#if ONIXS_ICEBOE_CXX17_NOEXCEPT
    template<typename U, Timestamp (U::*)() const noexcept> struct SFINAE_1 {};
    template<typename U> static char test(SFINAE_1<U, &U::transactTime>*);
#endif
 
    template<typename U> static int test(...);
    static constexpr bool value = sizeof(test<T>(nullptr)) == sizeof(char);
};
 
template<typename T>
struct hasExecIdImpl
{
    template<typename U, OrderExecID (U::*)() const noexcept> struct SFINAE {};
    template<typename U> static char test(SFINAE<U, &U::execId>*);
    template<typename U> static int test(...);
    static constexpr bool value = sizeof(test<T>(nullptr)) == sizeof(char);
};
 
template<typename T>
struct hasExecTypeImpl
{
    template<typename U, typename V, V (U::*)() const noexcept> struct SFINAE {};
    template<typename U> static char test(SFINAE<U, decltype(std::declval<const U&>().execType()), &U::execType>*);
    template<typename U> static int test(...);
    static constexpr bool value = sizeof(test<T>(nullptr)) == sizeof(char);
};
 
 
template<typename T>
struct hasLeavesQtyImpl
{
    template<typename U, typename V, V (U::*)() const noexcept> struct SFINAE {};
    template<typename U> static char test(SFINAE<U, decltype(std::declval<const U&>().leavesQty()), &U::leavesQty>*);
    template<typename U> static int test(...);
    static constexpr bool value = sizeof(test<T>(nullptr)) == sizeof(char);
};
 
}
 
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 MsgType>
Timestamp getTransactTime(MsgType&& msg, typename std::enable_if<hasTransactTime<MsgType>::value, void*>::type = nullptr)
{
    return msg.transactTime();
}
 
template <typename MsgType>
Timestamp getTransactTime(MsgType&& msg, typename std::enable_if<!hasTransactTime<MsgType>::value && hasExecId<MsgType>::value, void*>::type = nullptr)
{
    return msg.execId().transactTime();
}
 
template <typename MsgType>
Timestamp getTransactTime(MsgType&&, typename std::enable_if<!hasTransactTime<MsgType>::value && !hasExecId<MsgType>::value, void*>::type = nullptr)
{
    return Timestamp{};
}
 
template <typename MsgType>
ExecTypeEnum getOrdStatus(MsgType&& msg, ExecTypeEnum, typename std::enable_if<hasExecType<MsgType>::value, void*>::type=nullptr)
{
    return msg.execType();
}
 
template <typename MsgType>
ExecTypeEnum getOrdStatus(MsgType&&, ExecTypeEnum defaultValue, typename std::enable_if<!hasExecType<MsgType>::value, void*>::type=nullptr)
{
    return defaultValue;
}
 
template <typename MsgType>
void setOrdStatus(Order& order, MsgType&& msg, ExecTypeEnum defaultValue)
{
    order.orderStatus_ = getOrdStatus(msg, defaultValue);
}
 
template <typename MsgType>
void setLeavesQty(Order& order, MsgType&& msg, typename std::enable_if<hasLeavesQty<MsgType>::value, void*>::type=nullptr)
{
    order.leavesQty_ = msg.leavesQty();
}
 
template <typename MsgType>
void setLeavesQty(Order&, MsgType&&, typename std::enable_if<!hasLeavesQty<MsgType>::value, void*>::type=nullptr) {}
 
inline Decimal9 toPriceMantissa(Decimal value)
{
    return quantize(value, -9).mantissa();
}
 
template <typename T>
T parseUserInput(const std::string& userInput, typename std::enable_if<std::is_integral<T>::value, void*>::type = nullptr)
{
    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);
}
 
template <typename T>
T parseUserInput(const std::string& userInput, typename std::enable_if<isScopedEnum<T>::value, void*>::type = nullptr)
{
    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;
}
 
template <typename T>
Decimal parseUserInput(const std::string& userInput, typename std::enable_if<std::is_floating_point<T>::value, void*>::type = nullptr)
{
    Decimal value;
 
    if(fromStr(value, userInput))
        return value;
 
    throw std::invalid_argument("Invalid user input: '" + userInput + "'");
}
 
template <typename T>
T parseUserInput(const std::string& userInput, typename std::enable_if<std::is_same<T, std::string>::value, void*>::type = nullptr)
{
    return userInput;
}
 
 
template <typename T>
auto toValueNamePair(T v, typename std::enable_if<isScopedEnum<T>::value, void*>::type=nullptr)
{
    return toStr(toUnderlying(v)) + "-" + toStr(v);
}
 
template <typename It>
inline auto join(It first, It last, char delim, typename std::enable_if<isScopedEnum<typename It::value_type>::value, void*>::type=nullptr)
{
    if (first == last)
        return std::string{};
 
    std::ostringstream oss;
    oss << toValueNamePair(*first);
    ++first;
    for (; first != last; ++first)
        oss << delim << toValueNamePair(*first);
 
    return oss.str();
}

#ifdef ONIXS_ICEBOE_CXX17
template<typename T> using OptionalRef = std::optional<std::shared_ptr<T>>;
#else
template <typename T>
class OptionalRef
{
    using Ref = std::shared_ptr<T>;
 
public:
    OptionalRef() noexcept : has_(false) {}
 
    explicit OptionalRef(std::shared_ptr<T> t)
        : has_(true)
    {
        ::new (&storage_) Ref(t);
    }
 
    OptionalRef(const OptionalRef& o)
        : has_(o.has_)
    {
        if (has_) ::new (&storage_) Ref(*o.refptr());
    }
 
    OptionalRef(OptionalRef&& o) noexcept
        : has_(o.has_)
    {
        if (has_) ::new (&storage_) Ref(std::move(*o.refptr()));
    }
 
    ~OptionalRef() { if (has_) { refptr()->~Ref(); } }
 
    explicit operator bool() const noexcept { return has_; }
 
    Ref& operator*() { return value(); }
    const Ref& operator*() const { return value(); }
 
    Ref* operator->() { return &value(); }
    const Ref* operator->() const { return &value(); }
 
private:
    Ref* refptr() { return reinterpret_cast<Ref*>(&storage_); }
    const Ref* refptr() const { return reinterpret_cast<const Ref*>(&storage_); }
    Ref& value() { if (!has_) throwBadOptionalAccess(); return *refptr(); }
    const Ref& value() const { if (!has_) throwBadOptionalAccess(); return *refptr(); }
 
    using Storage = typename std::aligned_storage<sizeof(Ref), alignof(Ref)>::type;
 
    bool has_;
    Storage storage_;
};
#endif
 
}