MessageOperation.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 <cstddef>
#include <tuple>
#include <type_traits>
#include <utility>
 
#include <OnixS/CME/MDH/ABI.h>
#include <OnixS/CME/MDH/messaging/Fields.h>
 
ONIXS_CME_MDH_TESTING_NAMESPACE_BEGIN

namespace details
{
    struct MessageOperationBase{};
    template <typename MessageType> struct EntryOperationSelector;
    template <typename Callable> class CallableOperationFactory;
    template <typename SourceFactory, typename CustomizationFactory> class BoundMessageOperationFactory;
    template <std::size_t...> struct IndexSequence{};
    template <std::size_t Size, std::size_t... Indices> struct MakeIndexSequence : MakeIndexSequence<Size - 1, Size - 1, Indices...>{};
    template <std::size_t... Indices> struct MakeIndexSequence<0, Indices...> { using Type = IndexSequence<Indices...>; };
 
    template <typename Operation, typename Holder, typename Arguments, std::size_t... Indices>
    auto applyMessageOperation(Holder&& message, Arguments&& arguments, IndexSequence<Indices...>) -> decltype(
        Operation::apply(std::forward<Holder>(message), std::get<Indices>(std::forward<Arguments>(arguments))...))
    {
        return Operation::apply(
            std::forward<Holder>(message), std::get<Indices>(std::forward<Arguments>(arguments))...);
    }
 
    template <typename Operation, typename... Arguments>
    class MessageOperation : public MessageOperationBase
    {
    public:
        explicit MessageOperation(Arguments... arguments) : arguments_(std::move(arguments)...) {}
 
        template <typename Holder>
        auto apply(Holder&& message) const & -> decltype(applyMessageOperation<Operation>(
            std::forward<Holder>(message), std::declval<const std::tuple<Arguments...>&>(),
            typename MakeIndexSequence<sizeof...(Arguments)>::Type()))
        {
            return applyMessageOperation<Operation>(
                std::forward<Holder>(message), arguments_, typename MakeIndexSequence<sizeof...(Arguments)>::Type());
        }
 
        template <typename Holder>
        auto apply(Holder&& message) && -> decltype(applyMessageOperation<Operation>(
            std::forward<Holder>(message), std::declval<std::tuple<Arguments...>&&>(),
            typename MakeIndexSequence<sizeof...(Arguments)>::Type()))
        {
            return applyMessageOperation<Operation>(
                std::forward<Holder>(message), std::move(arguments_), typename MakeIndexSequence<sizeof...(Arguments)>::Type());
        }
 
    private:
        std::tuple<Arguments...> arguments_;
    };
 
    template <typename Operation, typename... Arguments>
    MessageOperation<Operation, typename std::decay<Arguments>::type...> makeMessageOperation(Arguments&&... arguments)
    {
        using Result = MessageOperation<Operation, typename std::decay<Arguments>::type...>;
        return Result(std::forward<Arguments>(arguments)...);
    }
 
    template <Messaging::UpdateAction::Enum Action>
    struct ContextualEntryOperation
    {
        template <typename Holder, typename... Arguments>
        static auto apply(Holder& message, Arguments&&... arguments) -> decltype(
            EntryOperationSelector<typename std::decay<Holder>::type::MessageType>::template apply<Action>(
                message, std::forward<Arguments>(arguments)...))
        {
            return EntryOperationSelector<typename std::decay<Holder>::type::MessageType>::template apply<Action>(
                message, std::forward<Arguments>(arguments)...);
        }
    };
 
    template <Messaging::UpdateAction::Enum Action, typename... Arguments>
    auto makeContextualEntryOperation(Arguments&&... arguments) -> decltype(
        makeMessageOperation<ContextualEntryOperation<Action>>(
            std::forward<Arguments>(arguments)...))
    {
        return makeMessageOperation<ContextualEntryOperation<Action>>(
            std::forward<Arguments>(arguments)...);
    }
 
    template <typename Factory>
    class DeferredMessageOperation
    {
    public:
        explicit DeferredMessageOperation(Factory factory)
            : factory_(std::move(factory))
            , consumed_(false)
        {
        }
 
        DeferredMessageOperation(const DeferredMessageOperation&) = delete;
        DeferredMessageOperation& operator=(const DeferredMessageOperation&) = delete;
 
        DeferredMessageOperation(DeferredMessageOperation&& other) noexcept(
            std::is_nothrow_move_constructible<Factory>::value)
            : factory_(std::move(other.factory_))
            , consumed_(other.consumed_)
        {
            other.consumed_ = true;
        }

        template <typename Callable>
        ONIXS_CMEMDH_NODISCARD
        auto operator%(Callable&& callable) && -> DeferredMessageOperation<BoundMessageOperationFactory<
            Factory, CallableOperationFactory<typename std::decay<Callable>::type>>>;
 
        auto materialize() && -> decltype(std::declval<Factory&>()())
        {
            assert(!consumed_);
            consumed_ = true;
            return factory_();
        }
 
        Factory releaseFactory() &&
        {
            assert(!consumed_);
            consumed_ = true;
            return std::move(factory_);
        }
 
    private:
        Factory factory_;
        bool consumed_;
    };
 
    template <typename Factory>
    ONIXS_CMEMDH_NODISCARD
    DeferredMessageOperation<typename std::decay<Factory>::type> deferMessageOperation(Factory&& factory)
    {
        using Result = DeferredMessageOperation<typename std::decay<Factory>::type>;
        return Result(std::forward<Factory>(factory));
    }
 
    struct CallableOperation
    {
        template <typename Holder, typename Callable>
        static auto apply(Holder& holder, Callable&& callable) -> decltype(
            std::forward<Callable>(callable)(holder.message()), holder)
        {
            std::forward<Callable>(callable)(holder.message());
            return holder;
        }
    };
 
    template <typename Callable>
    class CallableOperationFactory
    {
    public:
        template <typename Argument>
        explicit CallableOperationFactory(Argument&& callable)
            : callable_(std::forward<Argument>(callable))
        {
        }
 
        auto operator()() -> decltype(
            makeMessageOperation<CallableOperation>(std::declval<Callable&&>()))
        {
            return makeMessageOperation<CallableOperation>(std::move(callable_));
        }
 
    private:
        Callable callable_;
    };
 
    template <typename Result>
    class OperationResultHolder
    {
    public:
        explicit OperationResultHolder(Result& result) noexcept
            : result_(result)
        {
        }
 
        Result& message() noexcept
        {
            return result_;
        }
 
    private:
        Result& result_;
    };
 
    template <typename SourceOperation, typename CustomizationOperation>
    class BoundMessageOperation : public MessageOperationBase
    {
    public:
        BoundMessageOperation(SourceOperation source, CustomizationOperation customization)
            : source_(std::move(source))
            , customization_(std::move(customization))
        {
        }
 
        template <typename Holder>
        auto apply(Holder& holder) const -> decltype(
            std::declval<const CustomizationOperation&>().apply(
                std::declval<OperationResultHolder<typename std::remove_reference<decltype(
                    std::declval<const SourceOperation&>().apply(std::declval<Holder&>()))>::type>&>()),
            std::declval<const SourceOperation&>().apply(std::declval<Holder&>()))
        {
            using Result = decltype(source_.apply(holder));
            using Value = typename std::remove_reference<Result>::type;
 
            auto&& result = source_.apply(holder);
            OperationResultHolder<Value> resultHolder(result);
            customization_.apply(resultHolder);
            return std::forward<Result>(result);
        }
 
    private:
        SourceOperation source_;
        CustomizationOperation customization_;
    };
 
    template <typename SourceOperation, typename CustomizationOperation>
    BoundMessageOperation<typename std::decay<SourceOperation>::type, typename std::decay<CustomizationOperation>::type>
    makeBoundMessageOperation(SourceOperation&& source, CustomizationOperation&& customization)
    {
        using Result = BoundMessageOperation<
            typename std::decay<SourceOperation>::type,
            typename std::decay<CustomizationOperation>::type>;
        return Result(std::forward<SourceOperation>(source), std::forward<CustomizationOperation>(customization));
    }
 
    template <typename SourceFactory, typename CustomizationFactory>
    class BoundMessageOperationFactory
    {
    public:
        BoundMessageOperationFactory(SourceFactory source, CustomizationFactory customization)
            : source_(std::move(source))
            , customization_(std::move(customization))
        {
        }
 
        auto operator()() -> decltype(makeBoundMessageOperation(
            std::declval<SourceFactory&>()(), std::declval<CustomizationFactory&>()()))
        {
            auto source = source_();
            auto customization = customization_();
            return makeBoundMessageOperation(std::move(source), std::move(customization));
        }
 
    private:
        SourceFactory source_;
        CustomizationFactory customization_;
    };
 
    template <typename Factory>
    template <typename Callable>
    auto DeferredMessageOperation<Factory>::operator%(Callable&& callable) &&
        -> DeferredMessageOperation<BoundMessageOperationFactory<
            Factory, CallableOperationFactory<typename std::decay<Callable>::type>>>
    {
        using CustomizationFactory = CallableOperationFactory<typename std::decay<Callable>::type>;
        using BoundFactory = BoundMessageOperationFactory<Factory, CustomizationFactory>;
        return deferMessageOperation(BoundFactory(
            std::move(*this).releaseFactory(), CustomizationFactory(std::forward<Callable>(callable))));
    }
 
    template <std::size_t Index, std::size_t Size>
    struct ApplyMessageOperations
    {
        template <typename Holder, typename Operations>
        static void apply(Holder& holder, const Operations& operations)
        {
            std::get<Index>(operations).apply(holder);
            ApplyMessageOperations<Index + 1, Size>::apply(holder, operations);
        }
    };
 
    template <std::size_t Size>
    struct ApplyMessageOperations<Size, Size>
    {
        template <typename Holder, typename Operations>
        static void apply(Holder&, const Operations&)
        {
        }
    };
 
    template <typename Holder, typename Operation, typename Result, typename = void>
    struct ApplicableMessageOperationResult
    {
    };
 
    template <typename Holder, typename Operation, typename Result>
    struct ApplicableMessageOperationResult<Holder, Operation, Result, decltype(
        std::declval<const typename std::decay<Operation>::type&>().apply(std::declval<Holder&>()), void())>
    {
        using Type = Result;
    };
}

template <typename Holder, typename... Operations>
class MessageRecipe
{
    template <typename, typename...> friend class MessageRecipe;
 
public:
    using HolderType = Holder;

    explicit MessageRecipe(std::tuple<Operations...> operations)
        : operations_(std::move(operations))
    {
    }

    void applyTo(Holder& holder) const
    {
        details::ApplyMessageOperations<0, sizeof...(Operations)>::apply(holder, operations_);
    }

    Holder& operator()(Holder& holder) const
    {
        applyTo(holder);
        return holder;
    }

    template <typename Operation>
    auto append(Operation&& operation) const & -> typename details::ApplicableMessageOperationResult<
        Holder, Operation, MessageRecipe<Holder, Operations..., typename std::decay<Operation>::type>>::Type
    {
        using Result = MessageRecipe<Holder, Operations..., typename std::decay<Operation>::type>;
        return Result(std::tuple_cat(operations_, std::make_tuple(std::forward<Operation>(operation))));
    }

    template <typename Operation>
    auto append(Operation&& operation) && -> typename details::ApplicableMessageOperationResult<
        Holder, Operation, MessageRecipe<Holder, Operations..., typename std::decay<Operation>::type>>::Type
    {
        using Result = MessageRecipe<Holder, Operations..., typename std::decay<Operation>::type>;
        return Result(std::tuple_cat(std::move(operations_), std::make_tuple(std::forward<Operation>(operation))));
    }

    template <typename Callable>
    auto operator%(Callable&& callable) const & -> decltype(
        std::declval<const MessageRecipe&>().append(
            details::makeMessageOperation<details::CallableOperation>(std::forward<Callable>(callable))))
    {
        auto operation = details::makeMessageOperation<details::CallableOperation>(std::forward<Callable>(callable));
        return append(std::move(operation));
    }

    template <typename Callable>
    auto operator%(Callable&& callable) && -> decltype(
        std::move(*this).append(
            details::makeMessageOperation<details::CallableOperation>(std::forward<Callable>(callable))))
    {
        auto operation = details::makeMessageOperation<details::CallableOperation>(std::forward<Callable>(callable));
        return std::move(*this).append(std::move(operation));
    }
 
private:
    std::tuple<Operations...> operations_;
};

namespace details
{
    template <typename> struct IsMessageRecipe : std::false_type{};
 
    template <typename Holder, typename... Operations>
    struct IsMessageRecipe<MessageRecipe<Holder, Operations...>> : std::true_type{};
 
    template <typename Holder, typename Operation>
    MessageRecipe<Holder, typename std::decay<Operation>::type> makeMessageRecipe(Operation&& operation)
    {
        using Result = MessageRecipe<Holder, typename std::decay<Operation>::type>;
        return Result(std::make_tuple(std::forward<Operation>(operation)));
    }
}

template <typename Holder, typename Factory>
auto operator|(Holder& message, details::DeferredMessageOperation<Factory>&& deferredOperation) -> typename std::enable_if<
    !details::IsMessageRecipe<typename std::decay<Holder>::type>::value,
    decltype(std::move(deferredOperation).materialize().apply(message), message)>::type
{
    auto operation = std::move(deferredOperation).materialize();
    std::move(operation).apply(message);
    return message;
}

template <typename Holder, typename... Operations, typename Factory>
auto operator|(
    const MessageRecipe<Holder, Operations...>& recipe,
    details::DeferredMessageOperation<Factory>&& deferredOperation) -> decltype(
        recipe.append(std::move(deferredOperation).materialize()))
{
    auto operation = std::move(deferredOperation).materialize();
    return recipe.append(std::move(operation));
}

template <typename Holder, typename... Operations, typename Factory>
auto operator|(
    MessageRecipe<Holder, Operations...>&& recipe,
    details::DeferredMessageOperation<Factory>&& deferredOperation) -> decltype(
        std::move(recipe).append(std::move(deferredOperation).materialize()))
{
    auto operation = std::move(deferredOperation).materialize();
    return std::move(recipe).append(std::move(operation));
}

template <typename Holder, typename Operation>
auto operator|(Holder&, Operation&&) -> typename std::enable_if<
    !details::IsMessageRecipe<typename std::decay<Holder>::type>::value &&
        std::is_base_of<details::MessageOperationBase, typename std::decay<Operation>::type>::value,
    void>::type = delete;

template <typename Holder, typename... Operations, typename Operation>
auto operator|(const MessageRecipe<Holder, Operations...>&, Operation&&) -> typename std::enable_if<
    std::is_base_of<details::MessageOperationBase, typename std::decay<Operation>::type>::value,
    void>::type = delete;

template <typename Holder, typename... Operations, typename Operation>
auto operator|(MessageRecipe<Holder, Operations...>&&, Operation&&) -> typename std::enable_if<
    std::is_base_of<details::MessageOperationBase, typename std::decay<Operation>::type>::value,
    void>::type = delete;
 
ONIXS_CME_MDH_TESTING_NAMESPACE_END

#define ONIXS_CMEMDH_ENTRY(Action, ...)                                                                  \
    ONIXS_CME_MDH_TESTING_NAMESPACE::details::deferMessageOperation([&]() {                              \
        return ONIXS_CME_MDH_TESTING_NAMESPACE::details::makeContextualEntryOperation<                   \
            ONIXS_CMEMDH_MESSAGING_NAMESPACE::UpdateAction::Action>(__VA_ARGS__);                        \
    })