This sample demonstrates how to customize SBE encoding/decoding process.
#include "../../Common/PrecisionTimer.h"
#include "../../Common/Helpers.h"
#include "../../Common/Settings.h"
using namespace Settings;
namespace {
#pragma pack(push, 1)
struct MessageHeaderComposite
{
};
struct PacketHeaderComposite
{
};
struct PreMessageHeaderComposite
{
};
#pragma pack(pop)
{
public:
void queryCodingControl(CoderOwnerId owner ONIXS_FIXENGINE_UNUSED,
SbeFieldMetaData field ONIXS_FIXENGINE_UNUSED,
SbeFieldCodingSettings manageCoding) override {
}
ISbeFieldDecoder* queryDecoder(CoderOwnerId owner ONIXS_FIXENGINE_UNUSED, SbeFieldMetaData field) override {
return &userVarStringDecoder_;
return nullptr;
}
ISbeFieldEncoder* queryEncoder(CoderOwnerId owner ONIXS_FIXENGINE_UNUSED, SbeFieldMetaData field) override {
return &userVarStringEncoder_;
return nullptr;
}
ISbeGroupDimensionDecoder* queryGroupDimensionDecoder(CoderOwnerId owner ONIXS_FIXENGINE_UNUSED,
SbeFieldSetMetaData field) override {
return &userGroupSizeDecoder_;
return nullptr;
}
ISbeGroupDimensionEncoder* queryGroupDimensionEncoder(CoderOwnerId owner ONIXS_FIXENGINE_UNUSED, SbeFieldSetMetaData field) override {
return &userGroupSizeEncoder_;
return nullptr;
}
ISbeCompositeDecoder* queryDecoder(CoderOwnerId owner ONIXS_FIXENGINE_UNUSED, SbeTypeMetaData type) override {
if (!type.
name().compare(
"userMessageHeader"))
return &userMessageHeaderDecoder_;
return nullptr;
}
ISbeCompositeEncoder* queryEncoder(CoderOwnerId owner ONIXS_FIXENGINE_UNUSED, SbeTypeMetaData field) override {
if (!field.
name().compare(
"userMessageHeader"))
return &userMessageHeaderEncoder_;
return nullptr;
}
static unsigned getUnsigned(const char* src, size_t length) {
unsigned result = 0;
for (const char* current = src; (current - src) < (int)length; ++current) {
const char c = *current;
if (c >= '0' && c <= '9') {
result *= 10;
result += (c - '0');
}
else {
break;
}
}
return result;
}
static const size_t VarStringLengthFieldSize = 10;
class UserVarStringDecoder : public ISbeFieldDecoder
{
public:
size_t decode(SbeFieldDecoderOutput output, unsigned , const void* data, size_t available) override
{
if (available < VarStringLengthFieldSize)
throw std::domain_error("Not enough data to decode data length");
const char* chars = static_cast<const char*>(data);
unsigned length = getUnsigned(chars, VarStringLengthFieldSize);
if ((available - VarStringLengthFieldSize) < length)
throw std::domain_error("Not enough data to complete decoding");
output.
set(chars + VarStringLengthFieldSize, (SbeWireSize)length);
return VarStringLengthFieldSize + length;
}
};
UserVarStringDecoder userVarStringDecoder_;
class UserVarStringEncoder : public ISbeFieldEncoder
{
public:
return 0;
}
void encode(SbeBinaryOutputStream out, unsigned , const SbeConstFieldAccess& field) override {
std::string s;
throw std::domain_error("Unable to convert value to string");
char lengthBuffer[VarStringLengthFieldSize];
memset(lengthBuffer, 0, VarStringLengthFieldSize);
std::snprintf(lengthBuffer, VarStringLengthFieldSize, "%d", (int)s.length());
out.
put(lengthBuffer, VarStringLengthFieldSize);
out.
put(s.c_str(), (SbeWireSize)s.length());
}
};
UserVarStringEncoder userVarStringEncoder_;
static const size_t NumInGroupFieldSize = 6;
#pragma pack(push, 1)
struct UserGroupSizeLayout
{
char numInGroup[NumInGroupFieldSize];
};
#pragma pack(pop)
class UserGroupSizeDecoder : public ISbeGroupDimensionDecoder
{
public:
size_t decode(SbeGroupDimensionOutput output, unsigned , const void* data, size_t available) override
{
SbeFieldSetMetaData metadata = output.
group();
std::cout << "Decodes data for "
<< (metadata.
isGroup() ?
"group" :
"fieldset") <<
": "
<<
"<" << metadata.
tag() <<
"> "
<< std::endl;
if (available < sizeof(UserGroupSizeLayout))
throw std::domain_error("Not enough data to decode group dimension");
const UserGroupSizeLayout* groupSize = static_cast<const UserGroupSizeLayout*>(data);
unsigned numInGroups = getUnsigned(groupSize->numInGroup, NumInGroupFieldSize);
output.
set(groupSize->blockLength, (SbeWireSize)numInGroups);
return sizeof(UserGroupSizeLayout);
}
};
UserGroupSizeDecoder userGroupSizeDecoder_;
class UserGroupSizeEncoder : public ISbeGroupDimensionEncoder
{
public:
void encode(SbeBinaryOutputStream out, unsigned , SbeGroupDimensionInput input) override
{
std::cout << "Encodes data for "
<< (metadata.
isGroup() ?
"group" :
"fieldset") <<
": "
<<
"<" << metadata.
tag() <<
"> "
<< std::endl;
UserGroupSizeLayout groupSize;
memset(&groupSize, 0, sizeof(groupSize));
size_t numInGroups = 0;
groupSize.blockLength = (
UInt16)blockLength;
memset(groupSize.numInGroup, 0, NumInGroupFieldSize);
std::snprintf(groupSize.numInGroup, NumInGroupFieldSize, "%d", (int)numInGroups);
out.
put(&groupSize,
sizeof(groupSize));
}
};
UserGroupSizeEncoder userGroupSizeEncoder_;
#pragma pack(push, 1)
struct UserMessageHeaderLayout
{
unsigned char schemaId;
unsigned char version;
};
#pragma pack(pop)
class UserMessageHeaderDecoder : public ISbeCompositeDecoder
{
public:
size_t decode(SbeSpecialCompositeOutput output, unsigned , const void* data, size_t available) override
{
SbeTypeMetaData metadata = output.
type();
std::cout <<
"Decodes data for free composite \"" << metadata.
name() <<
"\"" << std::endl;
if (available < sizeof(UserMessageHeaderLayout))
throw std::domain_error("Not enough data to decode group dimension");
const UserMessageHeaderLayout* messageHeader = static_cast<const UserMessageHeaderLayout*>(data);
output.
setMessageHeader(messageHeader->blockLength, messageHeader->templateId, messageHeader->schemaId, messageHeader->version);
return sizeof(UserMessageHeaderLayout);
}
};
UserMessageHeaderDecoder userMessageHeaderDecoder_;
class UserMessageHeaderEncoder : public ISbeCompositeEncoder
{
public:
void encode(SbeBinaryOutputStream out, unsigned , SbeSpecialCompositeInput input) override
{
std::cout <<
"Encodes data for free composite \"" << metadata.
name() <<
"\"" << std::endl;
UserMessageHeaderLayout messageHeader;
memset(&messageHeader, 0, sizeof(messageHeader));
UInt32 blockLength, templateId, schemaId, version;
messageHeader.blockLength = (
UInt16)blockLength;
messageHeader.templateId = (
UInt16)templateId;
messageHeader.schemaId = (char)schemaId;
messageHeader.version = (char)version;
out.
put(&messageHeader,
sizeof(messageHeader));
}
};
UserMessageHeaderEncoder userMessageHeaderEncoder_;
};
void encodeAndDecode();
};
int main(int, char * [])
{
try {
EngineShutdownGuard engineShutdownGuard;
encodeAndDecode();
waitForAnyKey();
}
catch(const std::exception & ex) {
processSampleException(ex.what());
return 1;
}
}
namespace {
void encodeAndDecode() {
CustomCodersLibrary coderLib;
const std::string sbeTemplates = readTextFile("CustomizedSbeTemplate.xml");
msg.set(60, 12345);
msg.set(5799, 2);
Group group = msg.setGroup(268, 2);
group[0].set(279, 0);
group[0].set(269, 'J');
group[0].set(1180, 100);
group[0].set(8010, "Text for item 0");
group[1].set(279, 0);
group[1].set(269, 'J');
group[1].set(1180, 100);
msg.set(8001, "Variable length text");
msg.set(8002, "Another variable length text");
msg.updateBodyLengthAndCheckSum();
std::cout << msg.
toString() << std::endl;
Encoder encoder(sbeTemplates, &coderLib);
std::cout << "Message header type for encoding: " << encoder.schemaHeaderType() << std::endl;
unsigned char buffer[1024];
size_t rootBlockLength = 0;
size_t encoded = encoder.encodeWithHeader(msg, 104, 3, buffer, sizeof(buffer), &rootBlockLength);
Decoder decoder(sbeTemplates, dict, &coderLib);
int templateId = 0;
int version = 0;
const Message& decodedMsg = decoder.decode(buffer, encoded,
nullptr, &templateId, &version);
std::cout << decodedMsg.
toString() << std::endl;
}
};