MessageBuilder.h File Reference

Go to the source code of this file.

Classes
struct	HasExpectedMessageType< ExpectedHolder, Holder, bool >
struct	HasExpectedMessageType< ExpectedHolder, Holder, true >
struct	IsMutableMessageHolder< ExpectedHolder, Holder >
struct	MessageInitializationOperation< ExpectedHolder >
class	EntryRangeOperation< Operation >
class	EntryRangeStage< Action, Range, Projection >

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

Typedefs
template<typename Holder>
using	UnqualifiedMessageHolder = typename std::remove_cv<typename std::remove_reference<Holder>::type>::type
template<typename ExpectedHolder, typename Holder>
using	EnableMutableMessageHolder = typename std::enable_if<IsMutableMessageHolder<ExpectedHolder, Holder>::value, Holder&>::type

Functions
template<typename ExpectedHolder, typename Holder>
auto	initializeMessage (Holder &message, EventFlags::Bits eventIndicator, Messaging::Timestamp transactTime) noexcept -> EnableMutableMessageHolder< ExpectedHolder, Holder >
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
template<typename EntryCount>
EntryCount	checkedIncrementedEntryCount (EntryCount count)
template<typename Group, typename Resize>
Group::Entry	appendGroupEntry (Group group, Resize resize)
template<typename Range>
auto	rangeBegin (Range &range) -> decltype(begin(range))
template<typename Range>
auto	rangeEnd (Range &range) -> decltype(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))...))
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()))
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))...))
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()))
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 >
template<Messaging::UpdateAction::Enum Action, typename Range, typename Projection>
auto	makeEntryRangeOperation (Range &range, Projection &projection) -> decltype(makeEntryRangeOperationFromIterators< Action >(rangeBegin(range), rangeEnd(range), projection))
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 & >())
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)))
template<Messaging::UpdateAction::Enum Action, typename Range, typename Projection>
auto	entries (Range &&range, Projection &&projection) -> details::EntryRangeStage< Action, typename std::remove_reference< Range >::type, typename std::remove_reference< Projection >::type >
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()))
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()))