SBE B3 Sample

This sample provides a set of customized SBE codecs that can be used to handle BVMF entrypoint messages.

---

Source code:

• SbeB3Codecs.h
• SbeB3Codecs.cpp
• SbeB3.cpp

---

SbeB3Codecs.h:

 
#include <OnixS/FIXEngine/FIX/SbeCustomization.h>
#include <OnixS/FIXEngine/FIX/StringRef.h>
 
namespace OnixS {
namespace B3 {
 
using namespace OnixS::FIX;
using namespace OnixS::FIX::SBE;
 
#pragma pack(push, 1)

struct MessageHeaderComposite
{
    UInt16 blockLength;
    UInt16 templateId;
    UInt16 schemaId;
    UInt16 version;
};

struct FramingHeaderComposite
{
    UInt16 messageLength;
    UInt16 encodingType;

    void setup(UInt16 messageOnlySize) {
        messageLength = messageOnlySize + sizeof(FramingHeaderComposite);
        encodingType = 0xEB50U; // Little-endian mark.
    }
};
 
#pragma pack(pop)

size_t toHexString(char* buffer, const size_t bufferSize, const void* data, const size_t dataSize);

int hexToInt(char x);

size_t fromHexString(void* data, const size_t dataSize, const char* hex, const size_t hexLength);

template<typename T>
class HexStringCompositeDecoder : public ISbeFieldDecoder
{
public:
    typedef T DataType;
    size_t decode(SbeFieldDecoderOutput output, unsigned /* version */, const void* data, size_t available) ONIXS_FIXENGINE_OVERRIDE
    {
        const size_t DataSize = sizeof(DataType);
        if (available < DataSize)
            throw std::domain_error("Not enough data to decode custom composite");
 
        const DataType* typedData = static_cast<const DataType*>(data);
 
        char content[DataSize*2 + 1];
        size_t length = toHexString(content, sizeof(content), typedData, DataSize);
 
        output.set(content, (SbeWireSize)length);
        return DataSize;
    }
};

template<typename T>
class HexStringCompositeEncoder : public ISbeFieldEncoder
{
public:
    typedef T DataType;
 
    SbeWireSize queryFixedSize(unsigned /* version */) ONIXS_FIXENGINE_OVERRIDE
    {
        return (SbeWireSize)sizeof(DataType);
    }
 
    void encode(SbeBinaryOutputStream out, unsigned /* version */, const SbeConstFieldAccess& field) ONIXS_FIXENGINE_OVERRIDE
    {
        std::string s;
        if (!field.toString(s))
            throw std::domain_error("Unable to convert field value to string");
 
        DataType data;
        fromHexString(&data, sizeof(DataType), s.c_str(), s.length());
 
        out.put(&data, sizeof(data));
    }
};

class CodersLibrary : public ISbeCustomCoderLibrary
{
public:
    void queryCodingControl(CoderOwnerId /* owner */, SbeFieldMetaData /* field */,
        SbeFieldCodingSettings manageCoding) ONIXS_FIXENGINE_OVERRIDE {
        manageCoding.useFormattedDateTime(false); // Suppress time formatting.
        manageCoding.useValueNamesExternally(false); // Use enum raw values.
    }
 
 
    ISbeFieldDecoder* queryDecoder(CoderOwnerId owner, SbeFieldMetaData field) ONIXS_FIXENGINE_OVERRIDE;
    ISbeFieldEncoder* queryEncoder(CoderOwnerId owner, SbeFieldMetaData field) ONIXS_FIXENGINE_OVERRIDE;
 
public:
    // Customized coders for CustodianInfo
 
    //<composite name="CustodianInfo" description="Custodian information is required for going private offer.">
    //  <type name="custodian" primitiveType="uint32" presence="optional" nullValue="0" description="Identifies the custodian."/>
    //  <type name="custodyAccount" primitiveType="uint32" presence="optional" nullValue="0" description="Identifies the custody account."/>
    //  <type name="custodyAllocationType" primitiveType="uint32" presence="optional" nullValue="0" description="Custody allocation type."/>
    //</composite>
 
#pragma pack(push, 1)
    struct CustodianInfoLayout
    {
        UInt32 custodian;
        UInt32 custodyAccount;
        UInt32 custodyAllocationType;
 
        void fromString(const StringRef& ref) {
            OnixS::B3::fromHexString(this, sizeof(*this), ref.data(), ref.length());
        }
    };
#pragma pack(pop)
 
private:
    HexStringCompositeDecoder<CustodianInfoLayout> custodianInfoDecoder_;
    HexStringCompositeEncoder<CustodianInfoLayout> custodianInfoEncoder_;
 
public:
    // Customized coders for InboundBusinessHeader
 
    //<composite name="InboundBusinessHeader" description="Header used for inbound business messages.">
    //  <ref name="sessionID" type="SessionID"/>
    //  <ref name="msgSeqNum" type="SeqNum"/>
    //  <ref name="sendingTime" type="SendingTime"/>
    //  <ref name="marketSegmentID" type="MarketSegmentID"/>
    //  <type name="padding" primitiveType="char" semanticType="String" characterEncoding="ASCII" length="1" description="Padding for alignment purpose."/>
    //</composite>
 
#pragma pack(push, 1)
    struct InboundBusinessHeader
    {
        UInt32 sessionID;
        UInt32 msgSeqNum;
        UInt32 sendingTime;
        char marketSegmentID;
        char padding;
 
        void fromString(const StringRef& ref) {
            OnixS::B3::fromHexString(this, sizeof(*this), ref.data(), ref.length());
        }
    };
#pragma pack(pop)
 
private:
    HexStringCompositeDecoder<InboundBusinessHeader> inboundBusinessHeaderDecoder_;
    HexStringCompositeEncoder<InboundBusinessHeader> inboundBusinessHeaderEncoder_;
 
public:
    // Customized coders for OutboundBusinessHeader
 
    //<composite name="OutboundBusinessHeader" description="Header used for outbound business messages.">
    //  <ref name="sessionID" type="SessionID"/>
    //  <ref name="msgSeqNum" type="SeqNum"/>
    //  <ref name="sendingTime" type="SendingTime"/>
    //  <ref name="possResend" type="PossResend"/>
    //  <type name="padding" primitiveType="char" semanticType="String" characterEncoding="ASCII" length="1" description="Padding for alignment purpose."/>
    //</composite>
 
#pragma pack(push, 1)
    struct OutboundBusinessHeader
    {
        UInt32 sessionID;
        UInt32 msgSeqNum;
        UInt64 sendingTime;
        char possResend;
        char padding;
 
        void fromString(const StringRef& ref) {
            OnixS::B3::fromHexString(this, sizeof(*this), ref.data(), ref.length());
        }
    };
#pragma pack(pop)
 
private:
    HexStringCompositeDecoder<OutboundBusinessHeader> outboundBusinessHeaderDecoder_;
    HexStringCompositeEncoder<OutboundBusinessHeader> outboundBusinessHeaderEncoder_;
 
public:
    // Customized coders for BidirectionalBusinessHeader
 
    //<composite name="BidirectionalBusinessHeader" description="Header used for business messages that can go inbound or outbound.">
    //  <ref name="sessionID" type="SessionID"/>
    //  <ref name="msgSeqNum" type="SeqNum"/>
    //  <ref name="sendingTime" type="SendingTime"/>
    //  <ref name="possResend" type="PossResend"/>
    //  <ref name="marketSegmentID" type="MarketSegmentIDOptional"/>
    //  <type name="padding" primitiveType="char" semanticType="String" characterEncoding="ASCII" length="2" description="Padding for alignment purpose."/>
    //</composite>
 
#pragma pack(push, 1)
    struct BidirectionalBusinessHeader
    {
        UInt32 sessionID;
        UInt32 msgSeqNum;
        UInt32 sendingTime;
        char possResend;
        char marketSegmentID;
        char padding;
 
        void fromString(const StringRef& ref) {
            OnixS::B3::fromHexString(this, sizeof(*this), ref.data(), ref.length());
        }
    };
#pragma pack(pop)
 
private:
    HexStringCompositeDecoder<BidirectionalBusinessHeader> bidirectionalBusinessHeaderDecoder_;
    HexStringCompositeEncoder<BidirectionalBusinessHeader> bidirectionalBusinessHeaderEncoder_;
 
 
private:
    // Special decoders for framing header.
    // They are not used actually but required to successfully parse the template with the dummy message
    // that contains field of the FramingHeader type.
 
    HexStringCompositeDecoder<FramingHeaderComposite> framingHeaderBusinessHeaderDecoder_;
    HexStringCompositeEncoder<FramingHeaderComposite> framingHeaderBusinessHeaderEncoder_;
};
 
}
}
 

SbeB3Codecs.cpp:

 
#include "SbeB3Codecs.h"
 
namespace OnixS {
namespace B3 {
 
size_t toHexString(char* buffer, const size_t bufferSize, const void* data, const size_t dataSize) {
    if (bufferSize < (dataSize * 2 + 1)) {
        throw std::domain_error("Not enough buffer size for hexadecimal encoding.");
    }
 
    const char* digits = "0123456789ABCDEF";
    size_t counter = dataSize;
    for (const unsigned char* p = static_cast<const unsigned char*>(data); counter; --counter) {
        char x = digits[(*p) >> 4];
        *buffer++ = x;
        x = digits[(*p) & 0x0F];
        *buffer++ = x;
        ++p;
    }
    *buffer = 0;
    return dataSize * 2;
}
 
int hexToInt(char x) {
    if (x >= '0' && x <= '9') {
        return x - '0';
    }
    if (x >= 'a' && x <= 'f') {
        return 0xA + (x - 'a');
    }
    if (x >= 'A' && x <= 'F') {
        return 0xA + (x - 'A');
    }
    throw std::domain_error("Not a hexadecimal digit");
}
 
size_t fromHexString(void* data, const size_t dataSize, const char* hex, const size_t hexLength) {
    if (dataSize < hexLength / 2) {
        throw std::domain_error("Not enough buffer size for hexadecimal decoding.");
    }
    if (hexLength % 2) {
        throw std::domain_error("The hexadecimal string must be of an even length.");
    }
 
    char* dest = static_cast<char*>(data);
    for (size_t hLength = hexLength; hLength; hLength -= 2) {
        char c = *hex++;
        int v = hexToInt(c) << 4;
 
        c = *hex++;
        v += hexToInt(c);
 
        *dest++ = v;
    }
    return hexLength / 2;
}
 
ISbeFieldDecoder* CodersLibrary::queryDecoder(CoderOwnerId /* owner */, SbeFieldMetaData field) {
    if (!field.typeMetaData().name().compare("CustodianInfo"))
        return &custodianInfoDecoder_;
    if (!field.typeMetaData().name().compare("InboundBusinessHeader"))
        return &inboundBusinessHeaderDecoder_;
    if (!field.typeMetaData().name().compare("OutboundBusinessHeader"))
        return &outboundBusinessHeaderDecoder_;
    if (!field.typeMetaData().name().compare("BidirectionalBusinessHeader"))
        return &bidirectionalBusinessHeaderDecoder_;
    if (!field.typeMetaData().name().compare("FramingHeader"))
        return &framingHeaderBusinessHeaderDecoder_;
    return ONIXS_FIXENGINE_NULLPTR;
}
 
ISbeFieldEncoder* CodersLibrary::queryEncoder(CoderOwnerId /* owner */, SbeFieldMetaData field) {
    if (!field.typeMetaData().name().compare("CustodianInfo"))
        return &custodianInfoEncoder_;
    if (!field.typeMetaData().name().compare("InboundBusinessHeader"))
        return &inboundBusinessHeaderEncoder_;
    if (!field.typeMetaData().name().compare("OutboundBusinessHeader"))
        return &outboundBusinessHeaderEncoder_;
    if (!field.typeMetaData().name().compare("BidirectionalBusinessHeader"))
        return &bidirectionalBusinessHeaderEncoder_;
    if (!field.typeMetaData().name().compare("FramingHeader"))
        return &framingHeaderBusinessHeaderEncoder_;
    return ONIXS_FIXENGINE_NULLPTR;
}
 
}
}
 

SbeB3.cpp:

#include <OnixS/FIXEngine.h>
 
#include "SbeB3Codecs.h"
 
#include "../../Common/Helpers.h"
#include "../../Common/Settings.h"
 
using namespace Settings;
using namespace OnixS::FIX;
using namespace OnixS::FIX::SBE;
using namespace OnixS::Cryptography;
 
namespace {
 
void encodeAndDecode();
 
};
 
int main(int, const char * [])
{
    try {
        EngineSettings engineSettings;
        engineSettings.listenPort(-1)  // ListenPort is set to '-1' to disable the telecommunication level.
                      .licenseStore(LicenseStore);
 
        Engine::init(engineSettings);
 
        encodeAndDecode();
 
        std::cout << "Press Enter to exit." << std::endl;
        waitUntilEnterKey();
    }
    catch(const Exception & ex) {
        processSampleException(ex.what());
        return 3;
    }
}
 
namespace {
 
Message createPositionMaintenaceReport(const Dictionary &dictionary) {
 
    char customCompositeHex[256];
 
    Message msg("38", dictionary);
 
    // Create business header and encode it into hexadecimal string.
 
    OnixS::B3::CodersLibrary::OutboundBusinessHeader businessHeader;
    businessHeader.sessionID = 10;
    businessHeader.msgSeqNum = 1;
    businessHeader.sendingTime = (UInt64)Timestamp::utc().toUnixNanosecondTimestamp();
    businessHeader.possResend = 'Y';
    businessHeader.padding = 0;
 
    OnixS::B3::toHexString(customCompositeHex, sizeof(customCompositeHex), &businessHeader, sizeof(businessHeader));
 
    // ...the hexadecimal string is used as the value of FIX field:
    msg.set(35524, customCompositeHex);
 
    // Fill elements that will be reflected as fixed-size part of the SBE message.
 
    msg.set(710, 33); // posReqID
    msg.set(48, 10250); // securityID
    msg.set(22, '8'); //securityIDSource, SecurityIDSource.EXCHANGE_SYMBOL
    msg.set(207, "BVMF"); // securityExchange, constant
    msg.set(721, 12345); // posMaintRptID
    msg.set(709, 1); // posTransType
    msg.set(712, 1); // posMaintAction
    msg.set(722, 9); // posMaintStatus
    msg.set(1003, 37259); // tradeID
    msg.set(713, 43591); // origPosReqRefID
    msg.set(581, 39); // accountType
    msg.set(715, Timestamp::utc().toUnixNanosecondTimestamp() / (86400 * 1000000000LL)); // clearingBusinessDate
    msg.set(834, OnixS::FIX::Decimal(1, -4)); // thresholdAmount
    msg.set(60, Timestamp::utc().toUnixNanosecondTimestamp()); // transactTime
    msg.set(1, 999); // account
    msg.set(35503, 'T'); // senderLocation
    msg.set(723, 0); // posMaintResult
    msg.set(719, 1); // contraryInstructionIndicator
 
 
    // Create repeating group.
 
    OnixS::FIX::Group group = msg.setGroup(702, 2); // noPositions
    group[0].set(703, 'E'); // posType
    group[0].set(704, 100); // longQty
    group[0].set(705, 0); // shortQty
 
    group[1].set(703, 'E'); // posType
    group[1].set(704, 0); // longQty
    group[1].set(705, 110); // shortQty
 
    // Fill var-length data.
 
    msg.set(35510, "Test sample"); // deskID
    msg.set(5149, "Synthetic message"); // memo
    msg.set(58, "Don't use it in real trading!"); // text
 
    return msg;
}
 
OnixS::B3::FramingHeaderComposite* getFramingHeader(void* data) {
    return static_cast<OnixS::B3::FramingHeaderComposite*>(data);
}
 
void encodeAndDecode() {
    OnixS::B3::CodersLibrary coderLib;
 
    const std::string sbeTemplates = readTextFile("b3-entrypoint-messages-6.4.2.xml");
    Dictionary dict = Decoder::generateFixDictionary(sbeTemplates);
 
    Message msg = createPositionMaintenaceReport(dict);
 
    std::cout << "Message to encode: " << msg.toString() << std::endl;

 
    Encoder encoder(sbeTemplates, &coderLib);
 
    // The leading part of the buffer will be used for framing header.
    const size_t FramingHeaderSize = sizeof(OnixS::B3::FramingHeaderComposite);
 
    unsigned char encodedData[1000];
    size_t rootBlockLength = 0;
 
    // Encode the message and reserve area for the framing header.
    size_t messageDataSize = encoder.encodeWithHeader(msg, 503, 0, &encodedData[FramingHeaderSize], sizeof(encodedData)- FramingHeaderSize, &rootBlockLength);
 
    // Allocate framing header.
    OnixS::B3::FramingHeaderComposite *framingHeader = getFramingHeader(encodedData);
    framingHeader->setup((UInt16)messageDataSize);
 

 
    Decoder decoder(sbeTemplates, dict, &coderLib);
    int templateId = 0;
    int version = 0;
    size_t decodedBytes = 0;
 
    // Decode message with skipping of the framing header content.
    Message decodedMsg = decoder.decode(&encodedData[FramingHeaderSize], messageDataSize, &decodedBytes, &templateId, &version);
 
    std::cout << "Decoded message: " << decodedMsg.toString() << std::endl;
 
}
 
};