35 template <
typename SbeMessageType>
36 inline static SbeMessageType createMessage(
39 return SbeMessageType(data, length, version);
45 return "FieldsInitPolicy";
53 template <
typename SbeMessageType>
54 inline static SbeMessageType createMessage(
57 return SbeMessageType(
64 return "FieldsNoInitPolicy";
68template <
typename MessageType>
73 IsBaseOf<SbeMessage, MessageType>::value));
78 SbeType::EncodedLength
87 : MessageType(data, length, version)
96 : MessageType(data, length, version)
104 : MessageType(data, length)
124template <
typename,
size_t,
typename>
127 template <
typename,
size_t,
typename>
class HolderType,
129 size_t MaxMessageSize,
130 typename MessageInitializer>
133 const HolderType<MsgType, MaxMessageSize, MessageInitializer>& holder)
135 str +=
"MessageHolder[";
137 str +=
"BufferSize=";
138 toStr(str, holder.BufferSize);
140 str +=
", MessageInitializer=";
141 str += MessageInitializer::name();
144 toStr(str, *holder.header());
147 toStr(str, holder.message());
162 typename MessageTypeT,
163 size_t MaxMessageSize =
170 ONIXS_CONFLATEDTCP_STATIC_ASSERT_MSG(
172 "MaxMessageSize template parameter is too small");
174 ONIXS_CONFLATEDTCP_STATIC_ASSERT_MSG(
175 (MaxMessageSize >= GetMinMessageSize<SbeType>::Size),
176 "The buffer can not fit the message");
178 ONIXS_CONFLATEDTCP_STATIC_ASSERT_MSG(
180 "The buffer is too large.");
194#ifdef ONIXS_CONFLATEDTCP_MEMCHECK_DEBUG
195 std::memset(buffer_, magicDebugValue,
BufferSize);
199 message_ = MessageInitializer::template createMessage<MessageType>(
283 message().calculateBinarySize();
285 assert(calculatedMessageSize <= MaxMessageSize);
288 calculatedMessageSize >=
294 return calculatedMessageSize;
307 header()->setup(size + 2);
312#ifdef ONIXS_CONFLATEDTCP_MEMCHECK_DEBUG
313 std::memset(buffer_, magicDebugValue, BufferSize);
318 assert(r.message_.calculateBinarySize() <= MaxMessageSize);
334 MessageType message_;
335 unsigned char buffer_[BufferSize];
339 template <
typename,
size_t,
typename>
class HolderType,
341 size_t MaxMessageSize,
342 typename MessageInitializer>
344 const HolderType<MsgType, MaxMessageSize, MessageInitializer>& holder)
352 template <
typename,
size_t,
typename>
class HolderType,
354 size_t MaxMessageSize,
355 typename MessageInitializer>
357 std::ostream& stream,
358 const HolderType<MsgType, MaxMessageSize, MessageInitializer>& rhs)
360 return stream <<
toStr(rhs);
363#if defined(ONIXS_CONFLATEDTCP_CXX11)
366 typename MessageTypeT,
367 size_t MaxMessageSize =
370using MessageHolders = std::vector<MessageHolder<MessageTypeT, MaxMessageSize, MessageInitializer> >;
#define ONIXS_CONFLATEDTCP_MESSAGING_NAMESPACE_BEGIN
#define ONIXS_CONFLATEDTCP_MESSAGING_NAMESPACE_END
#define ONIXS_CONFLATEDTCP_FINAL
#define ONIXS_CONFLATEDTCP_CONST_OR_CONSTEXPR
#define ONIXS_CONFLATEDTCP_NOTHROW
#define ONIXS_CONFLATEDTCP_NODISCARD
#define ONIXS_CONFLATEDTCP_DEFAULT
Contains the SimpleOpenFramingHeader, the SBE message, and the data buffer.
std::string toString() const
MessageHolder & operator=(const MessageHolder &r)
SimpleOpenFramingHeader * header() noexcept
MessageType & message() noexcept
UInt16 messageSize() const noexcept
HeldAdapter< MessageTypeT > MessageType
Message type.
const MessageType & message() const noexcept
MessageHolder(SchemaVersion version=SbeType::Schema::Version)
MessageHolder(const MessageHolder &r)
const SimpleOpenFramingHeader * header() const noexcept
const unsigned char * buffer() const noexcept
MessageSize setHeader() noexcept
Calculates the binary size of the message and updates the Simple Open Framing Header accordingly.
const MessageType * operator->() const noexcept
UInt16 bufferSize() const noexcept
MessageType * operator->() noexcept
constexpr UInt8 DefaultMaxGroupItems
Default maximum number of repeating group items.
constexpr UInt16 MaxConflatedTcpMessageSize
Maximum supported message size.
MessageHeader::Version SchemaVersion
SBE-encoded data version type.
UInt16 MessageSize
Message length type.
std::vector< MessageHolder< MessageTypeT, MaxMessageSize, MessageInitializer > > MessageHolders
std::ostream & operator<<(std::ostream &stream, const Negotiate200 &obj)
Serializes into a stream.
void toStr(std::string &str, const Negotiate200 &obj)
Serializes into a string.
The policy to create messages with null-initialized optional fields.
The policy to create messages without initialized optional fields.
HeldAdapter(void *data, EncodedLength length, SbeMessage::NoFieldsInit, SchemaVersion version)
HeldAdapter(void *data, EncodedLength length, SbeMessage::NoInit, SbeMessage::NoCheck) noexcept
SbeType::EncodedLength EncodedLength
HeldAdapter(void *data, EncodedLength length, SbeMessage::NoInit)
ONIXS_CONFLATEDTCP_STATIC_ASSERT((IsBaseOf< SbeMessage, MessageType >::value))
static constexpr MessageSize getMinimalVariableFieldsSize(SchemaVersion version)
Minimal variable fields size (when variable-length fields are empty).
static constexpr BlockLength blockLength(SchemaVersion version) noexcept
Size of message body in bytes.