SnapshotFullRefresh.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/testing/MessageBuilder.h>
#include <OnixS/CME/MDH/testing/MessageHolder.h>
#include <OnixS/CME/MDH/Watch.h>
 
ONIXS_CME_MDH_TESTING_NAMESPACE_BEGIN

using SnapshotFullRefresh = MessageHolder<Messaging::SnapshotFullRefresh52>;

namespace details
{
    template <typename Holder>
    using EnableSnapshotFullRefresh = EnableMutableMessageHolder<SnapshotFullRefresh, Holder>;

    enum class SnapshotFullRefreshInitializationTag {};
 
    template <Messaging::UpdateAction::Enum Action>
    struct IsSnapshotFullRefreshAction : std::integral_constant<bool,
        Action == Messaging::UpdateAction::New>
    {};
 
    struct SnapshotFullRefreshInitializationOperation
    {
        template <typename Holder>
        static auto apply(
            Holder& message, Messaging::UInt32 totNumReports, SecurityId securityId,
            SequenceNumber lastMsgSeqNumProcessed, Messaging::UInt32 rptSeq,
            Messaging::Timestamp transactTime, Messaging::Timestamp updateTime) noexcept
                -> EnableSnapshotFullRefresh<Holder>
        {
            message->reset();
            message->setTotNumReports(totNumReports);
            message->setSecurityId(securityId);
            message->setLastMsgSeqNumProcessed(lastMsgSeqNumProcessed);
            message->setRptSeq(rptSeq);
            message->setTransactTime(transactTime);
            message->setLastUpdateTime(updateTime);
            message->setTradeDate(updateTime);
            message->setSecurityTradingStatus(Messaging::SecurityTradingStatus::NewPriceIndication);
 
            return message;
        }
    };
 
    template <typename Holder>
    Messaging::SnapshotFullRefresh52::Entry appendSnapshotFullRefreshEntry(
        Holder& message, Messaging::EntryType::Enum entryType, Messaging::Int8 priceLevel,
        Messaging::Decimal9 price, Messaging::Int32 quantity, Messaging::Int32 numberOfOrders)
    {
        auto entry = appendGroupEntry(message->entries(), [&message](
            typename decltype(message->entries())::Size size) { return message->entries(size); });
 
        entry.setEntryType(entryType);
        entry.setPriceLevel(priceLevel);
        entry.setEntryPx(price);
        entry.setEntrySize(quantity);
        entry.setNumberOfOrders(numberOfOrders);
        entry.setSettlPriceType(Messaging::SettlPriceType());
        entry.setOpenCloseSettlFlag(Messaging::OpenCloseSettlFlag::DailyOpenPrice);
 
        return entry;
    }
}

template <typename Holder, details::SnapshotFullRefreshInitializationTag...>
auto initialize(
    Holder& message, Messaging::UInt32 totNumReports, SecurityId securityId,
    SequenceNumber lastMsgSeqNumProcessed, Messaging::UInt32 rptSeq,
    Messaging::Timestamp transactTime, Messaging::Timestamp updateTime)
        -> details::EnableSnapshotFullRefresh<Holder>
{
    return details::SnapshotFullRefreshInitializationOperation::apply(
        message, totNumReports, securityId, lastMsgSeqNumProcessed, rptSeq, transactTime, updateTime);
}

template <typename Holder, details::SnapshotFullRefreshInitializationTag...>
auto initialize(
    Holder& message, Messaging::UInt32 totNumReports, SecurityId securityId,
    SequenceNumber lastMsgSeqNumProcessed, Messaging::UInt32 rptSeq,
    Messaging::Timestamp timestamp = UtcWatch::now())
        -> details::EnableSnapshotFullRefresh<Holder>
{
    return initialize(message, totNumReports, securityId, lastMsgSeqNumProcessed, rptSeq, timestamp, timestamp);
}

template <typename Holder, details::SnapshotFullRefreshInitializationTag...>
ONIXS_CMEMDH_NODISCARD
auto initialize(
    Messaging::UInt32 totNumReports, SecurityId securityId,
    SequenceNumber lastMsgSeqNumProcessed, Messaging::UInt32 rptSeq,
    Messaging::Timestamp transactTime, Messaging::Timestamp updateTime) -> decltype(
        details::makeInitializationRecipe<
            Holder, SnapshotFullRefresh, details::SnapshotFullRefreshInitializationOperation>(
                totNumReports, securityId, lastMsgSeqNumProcessed, rptSeq,
                transactTime, updateTime))
{
    return details::makeInitializationRecipe<
        Holder, SnapshotFullRefresh, details::SnapshotFullRefreshInitializationOperation>(
            totNumReports, securityId, lastMsgSeqNumProcessed, rptSeq,
            transactTime, updateTime);
}

template <typename Holder, details::SnapshotFullRefreshInitializationTag...>
ONIXS_CMEMDH_NODISCARD
auto initialize(
    Messaging::UInt32 totNumReports, SecurityId securityId,
    SequenceNumber lastMsgSeqNumProcessed, Messaging::UInt32 rptSeq,
    Messaging::Timestamp timestamp = UtcWatch::now()) -> decltype(
        initialize<Holder>(
            totNumReports, securityId, lastMsgSeqNumProcessed, rptSeq, timestamp, timestamp))
{
    return initialize<Holder>(totNumReports, securityId, lastMsgSeqNumProcessed, rptSeq, timestamp, timestamp);
}

template <typename Holder>
auto addEntry(
    Holder& message, Messaging::EntryType::Enum entryType, Messaging::Int8 priceLevel,
    Messaging::Decimal9 price, Messaging::Int32 quantity, Messaging::Int32 numberOfOrders)
        -> details::EnableSnapshotFullRefresh<Holder>
{
    details::appendSnapshotFullRefreshEntry(message, entryType, priceLevel, price, quantity, numberOfOrders);
    return message;
}

namespace details
{
    struct SnapshotFullRefreshEntryOperation
    {
        template <typename Holder, typename... Arguments>
        static auto apply(Holder& message, Arguments&&... arguments)
            -> decltype(addEntry(message, std::forward<Arguments>(arguments)...),
                appendSnapshotFullRefreshEntry(message, std::forward<Arguments>(arguments)...))
        {
            return appendSnapshotFullRefreshEntry(message, std::forward<Arguments>(arguments)...);
        }
    };
 
    template <>
    struct EntryOperationSelector<SnapshotFullRefresh::MessageType>
    {
        template <Messaging::UpdateAction::Enum Action, typename Holder, typename... Arguments>
        static auto apply(Holder& message, Arguments&&... arguments)
            -> typename std::enable_if<IsSnapshotFullRefreshAction<Action>::value,
                decltype(SnapshotFullRefreshEntryOperation::apply(message, std::forward<Arguments>(arguments)...))>::type
        {
            return SnapshotFullRefreshEntryOperation::apply(message, std::forward<Arguments>(arguments)...);
        }
    };
}
 
ONIXS_CME_MDH_TESTING_NAMESPACE_END