MessageBuilder.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 <cassert>
#include <iterator>
#include <limits>
#include <stdexcept>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>
 
#include <OnixS/CME/MDH/ABI.h>
#include <OnixS/CME/MDH/Messaging.h>
#include <OnixS/CME/MDH/testing/EventFlags.h>
#include <OnixS/CME/MDH/testing/MessageBuilderDiagnostics.h>
#include <OnixS/CME/MDH/testing/MessageOperation.h>
 
ONIXS_CME_MDH_TESTING_NAMESPACE_BEGIN

namespace details
{
    using std::begin;
    using std::end;
 
    template <typename Holder>
    using UnqualifiedMessageHolder = typename std::remove_cv<typename std::remove_reference<Holder>::type>::type;
 
    template <typename ExpectedHolder, typename Holder, bool = IsMessageHolder<UnqualifiedMessageHolder<Holder>>::value>
    struct HasExpectedMessageType : std::false_type
    {};
 
    template <typename ExpectedHolder, typename Holder>
    struct HasExpectedMessageType<ExpectedHolder, Holder, true> : std::is_same<
        typename ExpectedHolder::MessageHolderBase::MessageType, typename UnqualifiedMessageHolder<Holder>::MessageHolderBase::MessageType>
    {};
 
    template <typename ExpectedHolder, typename Holder>
    struct IsMutableMessageHolder : std::integral_constant<bool,
        HasExpectedMessageType<ExpectedHolder, Holder>::value && !std::is_const<typename std::remove_reference<Holder>::type>::value>
    {};
 
    template <typename ExpectedHolder, typename Holder>
    using EnableMutableMessageHolder = typename std::enable_if<IsMutableMessageHolder<ExpectedHolder, Holder>::value, Holder&>::type;
 
    template <typename ExpectedHolder>
    struct MessageInitializationOperation
    {
        template <typename Holder>
        static auto apply(Holder& message, EventFlags::Bits eventIndicator, Messaging::Timestamp transactTime) noexcept
                -> EnableMutableMessageHolder<ExpectedHolder, Holder>
        {
            message->reset();
            message->setMatchEventIndicator(Messaging::MatchEventIndicator(eventIndicator));
            message->setTransactTime(transactTime);
 
            return message;
        }
    };
 
    template <typename ExpectedHolder, typename Holder>
    auto initializeMessage(Holder& message, EventFlags::Bits eventIndicator, Messaging::Timestamp transactTime) noexcept
            -> EnableMutableMessageHolder<ExpectedHolder, Holder>
    {
        return MessageInitializationOperation<ExpectedHolder>::apply(
            message, eventIndicator, transactTime);
    }
 
    template <
        typename Holder, typename ExpectedHolder,
        typename Operation = MessageInitializationOperation<ExpectedHolder>,
        typename... Arguments>
    auto makeInitializationRecipe(Arguments&&... arguments) -> typename std::enable_if<
        IsMutableMessageHolder<ExpectedHolder, Holder>::value,
        decltype(makeMessageRecipe<typename std::decay<Holder>::type>(
            makeMessageOperation<Operation>(std::forward<Arguments>(arguments)...)))>::type
    {
        return makeMessageRecipe<typename std::decay<Holder>::type>(
            makeMessageOperation<Operation>(std::forward<Arguments>(arguments)...));
    }
 
    template <typename EntryCount>
    EntryCount checkedIncrementedEntryCount(EntryCount count)
    {
        if (count == (std::numeric_limits<EntryCount>::max)())
            throw std::runtime_error("Entry count limit exceeded");
 
        return static_cast<EntryCount>(count + 1);
    }
 
    template <typename Group, typename Resize>
    typename Group::Entry appendGroupEntry(Group group, Resize resize)
    {
        const auto index = group.size();
        const auto resizedGroup = resize(checkedIncrementedEntryCount(index));
        return resizedGroup[index];
    }
 
    template <typename Range>
    auto rangeBegin(Range& range) -> decltype(begin(range))
    {
        return begin(range);
    }
 
    template <typename Range>
    auto rangeEnd(Range& range) -> decltype(end(range))
    {
        return end(range);
    }
 
    template <Messaging::UpdateAction::Enum Action, typename Holder, typename Tuple, std::size_t... Indices>
    auto appendProjectedEntryArguments(Holder& message, Tuple&& arguments, IndexSequence<Indices...>)
        -> decltype(ContextualEntryOperation<Action>::apply(message, std::get<Indices>(std::forward<Tuple>(arguments))...))
    {
        return ContextualEntryOperation<Action>::apply(message, std::get<Indices>(std::forward<Tuple>(arguments))...);
    }
 
    template <Messaging::UpdateAction::Enum Action, typename Holder, typename Tuple>
    auto appendProjectedEntry(Holder& message, Tuple&& arguments)
        -> decltype(appendProjectedEntryArguments<Action>(message, std::forward<Tuple>(arguments),
            typename MakeIndexSequence<std::tuple_size<typename std::decay<Tuple>::type>::value>::Type()))
    {
        return appendProjectedEntryArguments<Action>(
            message, std::forward<Tuple>(arguments),
            typename MakeIndexSequence<std::tuple_size<typename std::decay<Tuple>::type>::value>::Type());
    }
 
    template <Messaging::UpdateAction::Enum Action, typename Tuple, std::size_t... Indices>
    auto makeProjectedEntryOperationArguments(Tuple&& arguments, IndexSequence<Indices...>)
        -> decltype(makeContextualEntryOperation<Action>(
            std::get<Indices>(std::forward<Tuple>(arguments))...))
    {
        return makeContextualEntryOperation<Action>(std::get<Indices>(std::forward<Tuple>(arguments))...);
    }
 
    template <Messaging::UpdateAction::Enum Action, typename Tuple>
    auto makeProjectedEntryOperation(Tuple&& arguments)
        -> decltype(makeProjectedEntryOperationArguments<Action>(std::forward<Tuple>(arguments),
            typename MakeIndexSequence<std::tuple_size<typename std::decay<Tuple>::type>::value>::Type()))
    {
        return makeProjectedEntryOperationArguments<Action>(
            std::forward<Tuple>(arguments),
            typename MakeIndexSequence<std::tuple_size<typename std::decay<Tuple>::type>::value>::Type());
    }
 
    template <typename Operation>
    class EntryRangeOperation : public MessageOperationBase
    {
    public:
        explicit EntryRangeOperation(std::vector<Operation> operations)
            : operations_(std::move(operations))
        {
        }
 
        template <typename Holder>
        auto apply(Holder& message) const
            -> decltype(std::declval<const Operation&>().apply(message), std::declval<Holder&>())
        {
            for (const auto& operation : operations_)
                operation.apply(message);
 
            return message;
        }
 
    private:
        std::vector<Operation> operations_;
    };
 
    template <Messaging::UpdateAction::Enum Action, typename Iterator, typename Sentinel, typename Projection>
    auto makeEntryRangeOperationFromIterators(Iterator first, Sentinel last, Projection& projection)
        -> EntryRangeOperation<typename std::decay<decltype(makeProjectedEntryOperation<Action>(projection(*first)))>::type>
    {
        using Operation = typename std::decay<decltype(makeProjectedEntryOperation<Action>(projection(*first)))>::type;
 
        std::vector<Operation> operations;
        for (; first != last; ++first)
            operations.push_back(makeProjectedEntryOperation<Action>(projection(*first)));
 
        return EntryRangeOperation<Operation>(std::move(operations));
    }
 
    template <Messaging::UpdateAction::Enum Action, typename Range, typename Projection>
    auto makeEntryRangeOperation(Range& range, Projection& projection)
        -> decltype(makeEntryRangeOperationFromIterators<Action>(rangeBegin(range), rangeEnd(range), projection))
    {
        auto first = rangeBegin(range);
        auto last = rangeEnd(range);
        return makeEntryRangeOperationFromIterators<Action>(std::move(first), std::move(last), projection);
    }
 
    template <Messaging::UpdateAction::Enum Action, typename Range, typename Projection>
    class EntryRangeStage
    {
    public:
        EntryRangeStage(Range& range, Projection& projection) noexcept
            : range_(&range)
            , projection_(&projection)
            , consumed_(false)
        {
        }
 
        EntryRangeStage(const EntryRangeStage&) = delete;
        EntryRangeStage& operator=(const EntryRangeStage&) = delete;
 
        EntryRangeStage(EntryRangeStage&& other) noexcept
            : range_(other.range_)
            , projection_(other.projection_)
            , consumed_(other.consumed_)
        {
            other.consumed_ = true;
        }
 
        auto materialize() && -> decltype(makeEntryRangeOperation<Action>(
            std::declval<Range&>(), std::declval<Projection&>()))
        {
            assert(!consumed_);
            consumed_ = true;
            return makeEntryRangeOperation<Action>(*range_, *projection_);
        }
 
    private:
        Range* range_;
        Projection* projection_;
        bool consumed_;
    };
 
    template <Messaging::UpdateAction::Enum Action, typename Holder, typename Iterator, typename Sentinel, typename Projection>
    auto addEntriesFromIterators(Holder& message, Iterator first, Sentinel last, Projection&& projection)
        -> decltype(
            static_cast<bool>(std::declval<Iterator&>() != std::declval<Sentinel&>()),
            ++std::declval<Iterator&>(),
            appendProjectedEntry<Action>(message, std::declval<Projection&>()(*std::declval<Iterator&>())),
            std::declval<Holder&>()
        )
    {
        for (; first != last; ++first)
            appendProjectedEntry<Action>(message, projection(*first));
 
        return message;
    }
}

template <Messaging::UpdateAction::Enum Action, typename Holder, typename Range, typename Projection>
auto addEntries(Holder& message, Range&& range, Projection&& projection)
    -> decltype(details::addEntriesFromIterators<Action>(
            message, details::rangeBegin(range), details::rangeEnd(range), std::forward<Projection>(projection)))
{
    auto first = details::rangeBegin(range);
    auto last = details::rangeEnd(range);
    return details::addEntriesFromIterators<Action>(message, std::move(first), std::move(last), std::forward<Projection>(projection));
}

template <Messaging::UpdateAction::Enum Action, typename Range, typename Projection>
ONIXS_CMEMDH_NODISCARD
auto entries(Range&& range, Projection&& projection)
    -> details::EntryRangeStage<
        Action, typename std::remove_reference<Range>::type, typename std::remove_reference<Projection>::type>
{
    return {range, projection};
}

template <typename Holder, typename... Operations, Messaging::UpdateAction::Enum Action, typename Range, typename Projection>
auto operator|(const MessageRecipe<Holder, Operations...>& recipe, details::EntryRangeStage<Action, Range, Projection>&& stage)
    -> decltype(recipe.append(std::move(stage).materialize()))
{
    auto operation = std::move(stage).materialize();
    return recipe.append(std::move(operation));
}

template <typename Holder, typename... Operations, Messaging::UpdateAction::Enum Action, typename Range, typename Projection>
auto operator|(MessageRecipe<Holder, Operations...>&& recipe, details::EntryRangeStage<Action, Range, Projection>&& stage)
    -> decltype(std::move(recipe).append(std::move(stage).materialize()))
{
    auto operation = std::move(stage).materialize();
    return std::move(recipe).append(std::move(operation));
}
 
ONIXS_CME_MDH_TESTING_NAMESPACE_END