IncrementalRefreshBook.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 <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/Order.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 IncrementalRefreshBook = MessageHolder<Messaging::IncrementalRefreshBook46>;

namespace details
{
    template <typename Holder>
    using EnableIncrementalRefreshBook = EnableMutableMessageHolder<IncrementalRefreshBook, Holder>;

    enum class IncrementalRefreshBookInitializationTag {};
 
    template <Messaging::UpdateAction::Enum Action> struct IsDeleteMdEntryAction : std::integral_constant<bool,
        Action == Messaging::UpdateAction::Delete ||
        Action == Messaging::UpdateAction::DeleteThru ||
        Action == Messaging::UpdateAction::DeleteFrom>
    {};
 
    template <Messaging::UpdateAction::Enum Action> struct IsValueMdEntryAction : std::integral_constant<bool,
        Action == Messaging::UpdateAction::New ||
        Action == Messaging::UpdateAction::Change ||
        Action == Messaging::UpdateAction::Overlay>
    {};
 
    template <Messaging::UpdateAction::Enum Action, typename Holder>
    using EnableDeleteMdEntry = typename std::enable_if<
        IsDeleteMdEntryAction<Action>::value, EnableIncrementalRefreshBook<Holder>>::type;
 
    template <Messaging::UpdateAction::Enum Action, typename Holder>
    using EnableValueMdEntry = typename std::enable_if<
        IsValueMdEntryAction<Action>::value, EnableIncrementalRefreshBook<Holder>>::type;
 
    template <Messaging::OrderUpdateAction::Enum Action> struct IsOrderIdEntryAction : std::integral_constant<bool,
        Action == Messaging::OrderUpdateAction::New ||
        Action == Messaging::OrderUpdateAction::Update ||
        Action == Messaging::OrderUpdateAction::Delete>
    {};
 
    template <Messaging::OrderUpdateAction::Enum Action, typename Holder>
    using EnableOrderIdEntry = typename std::enable_if<
        IsOrderIdEntryAction<Action>::value, EnableIncrementalRefreshBook<Holder>>::type;
 
    template <Messaging::UpdateAction::Enum Action, typename Holder>
    Messaging::IncrementalRefreshBook46::Entry appendMdEntryBase(
        Holder& message, SecurityId securityId, Messaging::EntryTypeBook::Enum entryType,
        Messaging::UInt32 rptSeq, Messaging::UInt8 priceLevel)
    {
        auto entry = appendGroupEntry(message->entries(), [&message](
            typename decltype(message->entries())::Size size) { return message->entries(size); });
 
        entry.setUpdateAction(Action);
        entry.setEntryType(entryType);
        entry.setSecurityId(securityId);
        entry.setRptSeq(rptSeq);
        entry.setPriceLevel(priceLevel);
 
        return entry;
    }
 
    template <Messaging::UpdateAction::Enum Action, typename Holder>
    Messaging::IncrementalRefreshBook46::Entry appendMdEntry(
        Holder& message, SecurityId securityId, Messaging::EntryTypeBook::Enum entryType,
        Messaging::UInt32 rptSeq, Messaging::UInt8 priceLevel)
    {
        auto entry = appendMdEntryBase<Action>(message, securityId, entryType, rptSeq, priceLevel);
 
        entry.entryPxNull();
        entry.entrySizeNull();
        entry.numberOfOrdersNull();
 
        return entry;
    }
 
    template <Messaging::UpdateAction::Enum Action, typename Holder>
    Messaging::IncrementalRefreshBook46::Entry appendMdEntry(
        Holder& message, SecurityId securityId, Messaging::EntryTypeBook::Enum entryType,
        Messaging::UInt32 rptSeq, Messaging::UInt8 priceLevel, Messaging::Decimal9 price,
        Messaging::Int32 quantity, Messaging::Int32 numberOfOrders)
    {
        auto entry = appendMdEntryBase<Action>(message, securityId, entryType, rptSeq, priceLevel);
 
        entry.setEntryPx(price);
        entry.setEntrySize(quantity);
        entry.setNumberOfOrders(numberOfOrders);
 
        return entry;
    }
 
    template <Messaging::OrderUpdateAction::Enum Action, typename Holder>
    Messaging::IncrementalRefreshBook46::OrderIDEntry appendOrderIdEntry(
        Holder& message, OrderId orderId, OrderPriority orderPriority, DisplayQuantity quantity,
        Messaging::UInt8 referenceId)
    {
        auto entry = appendGroupEntry(message->orderIdEntries(), [&message](
            typename decltype(message->orderIdEntries())::Size size) { return message->orderIdEntries(size); });
 
        entry.setOrderId(orderId);
        entry.setOrderPriority(orderPriority);
        entry.setDisplayQty(quantity);
        entry.setReferenceId(referenceId);
        entry.setOrderUpdateAction(Action);
 
        return entry;
    }
}

template <typename Holder, details::IncrementalRefreshBookInitializationTag...>
auto initialize(Holder& message, EventFlags::Bits eventIndicator, Messaging::Timestamp transactTime = UtcWatch::now()) noexcept
    -> details::EnableIncrementalRefreshBook<Holder>
{
    return details::initializeMessage<IncrementalRefreshBook>(message, eventIndicator, transactTime);
}

template <typename Holder, details::IncrementalRefreshBookInitializationTag...>
ONIXS_CMEMDH_NODISCARD
auto initialize(EventFlags::Bits eventIndicator, Messaging::Timestamp transactTime = UtcWatch::now()) -> decltype(
    details::makeInitializationRecipe<Holder, IncrementalRefreshBook>(eventIndicator, transactTime))
{
    return details::makeInitializationRecipe<Holder, IncrementalRefreshBook>(eventIndicator, transactTime);
}

template <Messaging::UpdateAction::Enum Action, typename Holder>
auto addEntry(
    Holder& message, SecurityId securityId, Messaging::EntryTypeBook::Enum entryType,
    Messaging::UInt32 rptSeq, Messaging::UInt8 priceLevel)
        -> details::EnableDeleteMdEntry<Action, Holder>
{
    details::appendMdEntry<Action>(message, securityId, entryType, rptSeq, priceLevel);
    return message;
}

template <Messaging::UpdateAction::Enum Action, typename Holder>
auto addEntry(
    Holder& message, SecurityId securityId, Messaging::EntryTypeBook::Enum entryType, Messaging::UInt32 rptSeq,
    Messaging::UInt8 priceLevel, Messaging::Decimal9 price, Messaging::Int32 quantity,
    Messaging::Int32 numberOfOrders)
        -> details::EnableValueMdEntry<Action, Holder>
{
    details::appendMdEntry<Action>(
        message, securityId, entryType, rptSeq, priceLevel, price, quantity, numberOfOrders);
    return message;
}

template <Messaging::OrderUpdateAction::Enum Action, typename Holder>
auto addOrderIdEntry(
    Holder& message, OrderId orderId, OrderPriority orderPriority, DisplayQuantity quantity,
    Messaging::UInt8 referenceId) -> details::EnableOrderIdEntry<Action, Holder>
{
    details::appendOrderIdEntry<Action>(message, orderId, orderPriority, quantity, referenceId);
    return message;
}

namespace details
{
    template <Messaging::UpdateAction::Enum Action>
    struct MdEntryOperation
    {
        template <typename Holder, typename... Arguments>
        static auto apply(Holder& message, Arguments&&... arguments) -> decltype(
            addEntry<Action>(message, std::forward<Arguments>(arguments)...),
            appendMdEntry<Action>(message, std::forward<Arguments>(arguments)...))
        {
            return appendMdEntry<Action>(message, std::forward<Arguments>(arguments)...);
        }
    };
 
    template <Messaging::OrderUpdateAction::Enum Action>
    struct OrderIdEntryOperation
    {
        template <typename Holder, typename... Arguments>
        static auto apply(Holder& message, Arguments&&... arguments) -> decltype(
            addOrderIdEntry<Action>(message, std::forward<Arguments>(arguments)...),
            appendOrderIdEntry<Action>(message, std::forward<Arguments>(arguments)...))
        {
            return appendOrderIdEntry<Action>(message, std::forward<Arguments>(arguments)...);
        }
    };
 
    template <>
    struct EntryOperationSelector<IncrementalRefreshBook::MessageType>
    {
        template <Messaging::UpdateAction::Enum Action, typename Holder, typename... Arguments>
        static auto apply(Holder& message, Arguments&&... arguments) -> typename std::enable_if<
            IsDeleteMdEntryAction<Action>::value || IsValueMdEntryAction<Action>::value,
            decltype(MdEntryOperation<Action>::apply(
                message, std::forward<Arguments>(arguments)...))>::type
        {
            return MdEntryOperation<Action>::apply(
                message, std::forward<Arguments>(arguments)...);
        }
    };
}

template <Messaging::OrderUpdateAction::Enum Action>
ONIXS_CMEMDH_NODISCARD
auto orderIdEntry(
    OrderId orderId, OrderPriority orderPriority, DisplayQuantity quantity,
    Messaging::UInt8 referenceId) -> typename std::enable_if<
        details::IsOrderIdEntryAction<Action>::value,
        decltype(details::makeMessageOperation<details::OrderIdEntryOperation<Action>>(
            orderId, orderPriority, quantity, referenceId))>::type
{
    return details::makeMessageOperation<details::OrderIdEntryOperation<Action>>(
        orderId, orderPriority, quantity, referenceId);
}
 
ONIXS_CME_MDH_TESTING_NAMESPACE_END

#define ONIXS_CMEMDH_ORDER_ID_ENTRY(Action, ...)                                                          \
    ONIXS_CME_MDH_TESTING_NAMESPACE::details::deferMessageOperation([&]() {                              \
        return ONIXS_CME_MDH_TESTING_NAMESPACE::orderIdEntry<                                            \
            ONIXS_CMEMDH_MESSAGING_NAMESPACE::OrderUpdateAction::Action>(__VA_ARGS__);                   \
    })