MessageOperation.h File Reference

Go to the source code of this file.

Classes
struct	MessageOperationBase
class	MessageOperation< Operation, Arguments >
struct	ContextualEntryOperation< Action >
class	DeferredMessageOperation< Factory >
struct	CallableOperation
class	CallableOperationFactory< Callable >
class	OperationResultHolder< Result >
class	BoundMessageOperation< SourceOperation, CustomizationOperation >
class	BoundMessageOperationFactory< SourceFactory, CustomizationFactory >
struct	ApplyMessageOperations< Index, Size >
struct	ApplyMessageOperations< Size, Size >
struct	ApplicableMessageOperationResult< Holder, Operation, Result, typename >
struct	ApplicableMessageOperationResult< Holder, Operation, Result, decltype(std::declval< const typename std::decay< Operation >::type & >().apply(std::declval< Holder & >()), void())>
class	MessageRecipe< Holder, Operations >
struct	IsMessageRecipe< typename >
struct	IsMessageRecipe< MessageRecipe< Holder, Operations... > >

Namespaces
namespace	OnixS
namespace	OnixS::CME
namespace	OnixS::CME::MDH
namespace	OnixS::CME::MDH::Test
namespace	OnixS::CME::MDH::Test::details

Macros
#define	ONIXS_CMEMDH_ENTRY(Action, ...)

Functions
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))...))
template<typename Operation, typename... Arguments>
MessageOperation< Operation, typename std::decay< Arguments >::type... >	makeMessageOperation (Arguments &&... arguments)
template<Messaging::UpdateAction::Enum Action, typename... Arguments>
auto	makeContextualEntryOperation (Arguments &&... arguments) -> decltype(makeMessageOperation< ContextualEntryOperation< Action > >(std::forward< Arguments >(arguments)...))
template<typename Factory>
DeferredMessageOperation< typename std::decay< Factory >::type >	deferMessageOperation (Factory &&factory)
template<typename SourceOperation, typename CustomizationOperation>
BoundMessageOperation< typename std::decay< SourceOperation >::type, typename std::decay< CustomizationOperation >::type >	makeBoundMessageOperation (SourceOperation &&source, CustomizationOperation &&customization)
template<typename Holder, typename Operation>
MessageRecipe< Holder, typename std::decay< Operation >::type >	makeMessageRecipe (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
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()))
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()))

Macro Definition Documentation

ONIXS_CMEMDH_ENTRY

#define ONIXS_CMEMDH_ENTRY	(		Action,
			... )

Value:

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

Creates a deferred market-data entry pipeline stage.

Parameters

Action	Unqualified Messaging::UpdateAction enumerator name.
...	Arguments forwarded to the holder-specific entry operation when the stage is applied.

Note

Stages are materialized in pipeline order. Argument evaluation within one entry operation follows the normal C++ function-argument rules.

Apply % callable to customize the entry created by this stage.

Warning

An entry view passed to a customization callable is valid only for that invocation. Do not retain it; growing any earlier repeating group can relocate and invalidate the view.

Note

This macro must be expanded within function scope because its stage factory captures referenced arguments by reference.

Warning

The returned stage may retain references or pointers to objects used by the argument expressions. Materialize it by piping it into a holder or appending it to a MessageRecipe before any such object's lifetime ends. Do not return or retain an unmaterialized stage beyond those lifetimes.

Note

Once appended, the MessageRecipe owns decay-copied argument values and may be retained and reused. Objects referenced indirectly by pointer-like or view-like argument values must still remain valid while the recipe is applied.

The returned deferred stage is single-use. Append it to a MessageRecipe once, then reuse the recipe when repeated materialization is required.

Definition at line 585 of file MessageOperation.h.