QuoteRequest.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 <algorithm>
#include <array>
#include <cassert>
#include <cstddef>
#include <string>
#include <type_traits>
#include <utility>
 
#include <OnixS/CME/MDH/ABI.h>
#include <OnixS/CME/MDH/Domain.h>
#include <OnixS/CME/MDH/Messaging.h>
#include <OnixS/CME/MDH/testing/MessageBuilder.h>
#include <OnixS/CME/MDH/testing/MessageHolder.h>
#include <OnixS/CME/MDH/testing/EventFlags.h>
#include <OnixS/CME/MDH/Watch.h>
 
ONIXS_CME_MDH_TESTING_NAMESPACE_BEGIN

using QuoteRequest = MessageHolder<Messaging::QuoteRequest39>;

namespace details
{
    template <typename Holder>
    using EnableQuoteRequest = EnableMutableMessageHolder<QuoteRequest, Holder>;
 
    class QuoteSymbol
    {
    public:
        enum : std::size_t { Capacity = 20 };
 
        explicit QuoteSymbol(Messaging::StrRef symbol) noexcept
            : size_((std::min)(symbol.size(), static_cast<std::size_t>(Capacity)))
        {
            assert(symbol.size() <= Capacity && "The string is truncated.");
 
            if (size_ != 0)
                std::copy_n(symbol.data(), size_, value_.data());
        }
 
        operator Messaging::StrRef() const noexcept
        {
            return Messaging::StrRef(value_.data(), size_);
        }
 
    private:
        std::array<Messaging::Char, Capacity> value_{};
        std::size_t size_;
    };

    enum class QuoteRequestInitializationTag {};
 
    struct QuoteRequestInitializationOperation
    {
        template <typename Holder>
        static auto apply(
            Holder& message, Messaging::StrRef quoteRequestId, EventFlags::Bits eventIndicator,
            Messaging::Timestamp transactTime) noexcept -> EnableQuoteRequest<Holder>
        {
            message->reset();
            message->setQuoteReqId(quoteRequestId);
            message->setMatchEventIndicator(Messaging::MatchEventIndicator(eventIndicator));
            message->setTransactTime(transactTime);
 
            return message;
        }
    };
 
    template <typename Holder>
    Messaging::QuoteRequest39::RelatedSymEntry appendQuoteEntry(
        Holder& message, SecurityId securityId, Messaging::StrRef symbol,
        Messaging::Int8 quoteType, Messaging::Int32 orderQuantity, Messaging::Int8 side)
    {
        auto entry = appendGroupEntry(message->relatedSym(), [&message](
            typename decltype(message->relatedSym())::Size size) { return message->relatedSym(size); });
 
        entry.setSecurityId(securityId);
        entry.setSymbol(symbol);
        entry.setQuoteType(quoteType);
        entry.setOrderQty(orderQuantity);
        entry.setSide(side);
 
        return entry;
    }
}

template <typename Holder, details::QuoteRequestInitializationTag...>
auto initialize(
    Holder& message, Messaging::StrRef quoteRequestId,
    EventFlags::Bits eventIndicator = EventFlags::None,
    Messaging::Timestamp transactTime = UtcWatch::now()) -> details::EnableQuoteRequest<Holder>
{
    return details::QuoteRequestInitializationOperation::apply(
        message, quoteRequestId, eventIndicator, transactTime);
}

template <typename Holder, details::QuoteRequestInitializationTag...>
ONIXS_CMEMDH_NODISCARD
auto initialize(
    Messaging::StrRef quoteRequestId, EventFlags::Bits eventIndicator = EventFlags::None,
    Messaging::Timestamp transactTime = UtcWatch::now()) -> decltype(
        details::makeInitializationRecipe<
            Holder, QuoteRequest, details::QuoteRequestInitializationOperation>(
                quoteRequestId, eventIndicator, transactTime))
{
    return details::makeInitializationRecipe<
        Holder, QuoteRequest, details::QuoteRequestInitializationOperation>(
            quoteRequestId, eventIndicator, transactTime);
}

template <typename Holder, typename String, details::QuoteRequestInitializationTag...>
auto initialize(
    String&& quoteRequestId, EventFlags::Bits eventIndicator = EventFlags::None,
    Messaging::Timestamp transactTime = UtcWatch::now()) -> typename std::enable_if<
        std::is_same<typename std::decay<String>::type, std::string>::value &&
        !std::is_lvalue_reference<String>::value>::type = delete;

template <typename Holder>
auto addQuoteEntry(
    Holder& message, SecurityId securityId, Messaging::StrRef symbol,
    Messaging::Int8 quoteType, Messaging::Int32 orderQuantity, Messaging::Int8 side)
        -> details::EnableQuoteRequest<Holder>
{
    details::appendQuoteEntry(message, securityId, symbol, quoteType, orderQuantity, side);
    return message;
}

namespace details
{
    struct QuoteEntryOperation
    {
        template <typename Holder, typename... Arguments>
        static auto apply(Holder& message, Arguments&&... arguments) -> decltype(
            addQuoteEntry(message, std::forward<Arguments>(arguments)...),
            appendQuoteEntry(message, std::forward<Arguments>(arguments)...))
        {
            return appendQuoteEntry(message, std::forward<Arguments>(arguments)...);
        }
    };
}

ONIXS_CMEMDH_NODISCARD
inline auto quoteEntry(
    SecurityId securityId, Messaging::StrRef symbol, Messaging::Int8 quoteType,
    Messaging::Int32 orderQuantity, Messaging::Int8 side) -> decltype(
        details::makeMessageOperation<details::QuoteEntryOperation>(
            securityId, details::QuoteSymbol(symbol), quoteType, orderQuantity, side))
{
    return details::makeMessageOperation<details::QuoteEntryOperation>(
        securityId, details::QuoteSymbol(symbol), quoteType, orderQuantity, side);
}
 
ONIXS_CME_MDH_TESTING_NAMESPACE_END

#define ONIXS_CMEMDH_QUOTE_ENTRY(...)                                                                     \
    ONIXS_CME_MDH_TESTING_NAMESPACE::details::deferMessageOperation([&]() {                               \
        return ONIXS_CME_MDH_TESTING_NAMESPACE::quoteEntry(__VA_ARGS__);                                  \
    })