SbeCustomization.h

Go to the documentation of this file.

#pragma once
/*
* Copyright Onix Solutions Limited [OnixS]. All rights reserved.
*
* This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
* and international copyright treaties.
*
* Access to and use of the software is governed by the terms of the applicable ONIXS Software
* Services Agreement (the Agreement) and Customer end user license agreements granting
* a non-assignable, non-transferable and non-exclusive license to use the software
* for it's own data processing purposes under the terms defined in the Agreement.
*
* Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
* of this source code or associated reference material to any other location for further reproduction
* or redistribution, and any amendments to this copyright notice, are expressly prohibited.
*
* Any reproduction or redistribution for sale or hiring of the Software not in accordance with
* the terms of the Agreement is a violation of copyright law.
*/
 
#include <cstddef>
#include <string>
#include <limits>
 
#include <OnixS/FIXEngine/ABI.h>
#include <OnixS/FIXEngine/Compiler.h>
#include <OnixS/FIXEngine/FIX/Numeric.h>
#include <OnixS/FIXEngine/FIX/Timestamp.h>
#include <OnixS/FIXEngine/FIX/Tag.h>
 
namespace OnixS {
namespace FIX {
ONIXS_FIXENGINE_API_DECL(class, Message);
ONIXS_FIXENGINE_API_DECL(class, Dictionary);
 
namespace SBE {

typedef UInt32 SbeWireSize;

typedef UInt64 CoderOwnerId;

const SbeWireSize UnusedWireSizeValue = (std::numeric_limits<SbeWireSize>::max)();

struct SbePresence {
    enum Enum {
        Required,

        Optional,

        Constant
    };
};

struct SbeEndianness {
    enum Enum {
        BigEndian,

        LittleEndian
    };
};

struct SbePrimitiveType {
    enum Enum {
        Unknown,

        Char,

        Int8,

        Int16,

        Int32,

        Int64,

        UInt8,

        UInt16,

        UInt32,

        UInt64,

        Float,

        Double
    };
};

struct SbeFixSemanticType {
    enum Enum {
        Unknown,

        Int,

        Length,

        TagNum,

        SeqNum,

        NumInGroup,

        DayOfMonth,

        Qty,

        Float,

        Price,

        PriceOffset,

        Amt,

        Percentage,

        Char,

        StringFixed,

        StringVariable,

        StringEncodedText,

        Data,

        XmlData,

        Country,

        Currency,

        Exchange,

        Language,

        ImplicitEnum,

        Boolean,

        MultipleCharValue,

        MultipleStringValue,

        MonthYear,

        UtcTimestamp,

        UtcTimeOnly,

        UtcDateOnly,

        LocalMktDate,

        TzTimeOnly,

        TzTimestamp
    };
};
 
class SbeSchemaMetaData;

class ONIXS_FIXENGINE_API ISbeNameDescription
{
public:
    virtual ~ISbeNameDescription() = default;

    virtual const std::string &name() const = 0;

    virtual const std::string &description() const = 0;
};

class ONIXS_FIXENGINE_API ISchemaMember : public ISbeNameDescription
{
public:
    virtual bool hasSchema() const = 0;

    virtual SbeSchemaMetaData schema() const = 0;
};

class ONIXS_FIXENGINE_API SbeNamedValueMetaData : public ISchemaMember
{
public:
    const std::string& name() const override;

    const std::string& description() const override;

    bool hasSchema() const override;

    SbeSchemaMetaData schema() const override;

    const std::string& value() const;
private:
    friend SbeNamedValueMetaData createSbeNamedValueMetaData(const void*);
    SbeNamedValueMetaData() {}
    SbeNamedValueMetaData(const void*);
    const void* details_;
};

class ONIXS_FIXENGINE_API SbeTypeMetaData : public ISchemaMember
{
public:
    const std::string& name() const override;

    const std::string& description() const override;

    bool hasSchema() const override;

    SbeSchemaMetaData schema() const override;

    unsigned sinceVersion() const;

    bool isSet() const;

    bool isEnumeration() const;

    bool isComposite() const;

    bool isSimple() const;

    bool isArray() const;

    SbePrimitiveType::Enum primitiveType() const;

    SbeWireSize fixedSize() const;

    SbeWireSize arraySize() const;

    SbeWireSize localOffset() const;

    SbePresence::Enum presence() const;

    const std::string& nullValue() const;

    const std::string& minValue() const;

    const std::string& maxValue() const;

    const std::string& constValue() const;

    SbeFixSemanticType::Enum semanticType() const;

    const std::string& rawSemanticType() const;

    const std::string& timeEpoch() const;

    const std::string& timeUnit() const;

    size_t noOfMembers() const;

    SbeTypeMetaData member(size_t) const;

    size_t noOfValues() const;

    SbeNamedValueMetaData value(size_t) const;
private:
    friend SbeTypeMetaData createSbeTypeMetaData(const void*);
    SbeTypeMetaData() {}
    SbeTypeMetaData(const void*);
    const void *details_;
};

class ONIXS_FIXENGINE_API SbeFieldSetMetaData : public ISchemaMember
{
public:
    const std::string& name() const override;

    const std::string& description() const override;

    bool hasSchema() const override;

    SbeSchemaMetaData schema() const override;

    bool hasParent() const;

    const SbeFieldSetMetaData parent() const;

    int tag() const;

    bool isGroup() const;

    bool isMessage() const;

    SbeTypeMetaData groupDimensionType() const;

    const std::string& messageSemanticType() const;
private:
    friend SbeFieldSetMetaData createSbeFieldSetMetaData(const void*);
    SbeFieldSetMetaData() {}
    SbeFieldSetMetaData(const void*);
    const void* details_;
};
 
class ONIXS_FIXENGINE_API SbeFieldMetaData : public ISchemaMember
{
public:
    const std::string& name() const override;

    const std::string& description() const override;

    bool hasSchema() const override;

    SbeSchemaMetaData schema() const override;

    SbeFieldSetMetaData parent() const;

    int tag() const;

    bool isGroup() const;

    SbeFieldSetMetaData group() const;

    SbeTypeMetaData typeMetaData() const;
private:
    friend SbeFieldMetaData createSbeFieldMetaData(const void*);
    SbeFieldMetaData() {}
    SbeFieldMetaData(const void*);
    const void* details_;
};

class ONIXS_FIXENGINE_API SbeSchemaMetaData : public ISbeNameDescription
{
public:
    const std::string& name() const override;

    const std::string& description() const override;

    UInt32 id() const;

    const std::string& package() const;

    unsigned version() const;

    const std::string& semanticVersion() const;

    SbeEndianness::Enum byteOrder() const;

    bool hasHeaderType() const;

    SbeTypeMetaData headerType() const;
private:
    friend SbeSchemaMetaData createSbeSchemaMetaData(const void*);
    SbeSchemaMetaData() {}
    SbeSchemaMetaData(const void*);
    const void* details_;
};
 
class ISbeManageCodingParameters;
class ISbeFieldDecoder;
class ISbeGroupDimensionDecoder;
class ISbeCompositeDecoder;
class ISbeFieldEncoder;
class ISbeGroupDimensionEncoder;
class ISbeCompositeEncoder;

class ONIXS_FIXENGINE_API SbeFieldCodingSettings
{
public:
    ~SbeFieldCodingSettings() = default;


    void useValueNamesExternally(bool);

    bool useValueNamesExternally() const;


    void useFormattedDateTime(bool);

    bool useFormattedDateTime() const;
private:
    friend SbeFieldCodingSettings createSbeFieldCodingSettings(void*);
    SbeFieldCodingSettings() {}
    SbeFieldCodingSettings(void*);
    void* details_;
};

class ONIXS_FIXENGINE_API ISbeCustomCoderLibrary
{
public:
    virtual ~ISbeCustomCoderLibrary() = default;


    virtual void attach(ONIXS_FIXENGINE_UNUSED CoderOwnerId owner) {}

    virtual void detach(ONIXS_FIXENGINE_UNUSED CoderOwnerId owner) {}
 


    virtual void queryCodingControl(ONIXS_FIXENGINE_UNUSED CoderOwnerId owner,
                                    ONIXS_FIXENGINE_UNUSED SbeFieldMetaData field,
                                    ONIXS_FIXENGINE_UNUSED SbeFieldCodingSettings settings) {}



    virtual ISbeFieldDecoder* queryDecoder(ONIXS_FIXENGINE_UNUSED CoderOwnerId owner,
                                           ONIXS_FIXENGINE_UNUSED SbeFieldMetaData field) { return nullptr; }

    virtual ISbeGroupDimensionDecoder* queryGroupDimensionDecoder(ONIXS_FIXENGINE_UNUSED CoderOwnerId owner,
                                                                  ONIXS_FIXENGINE_UNUSED SbeFieldSetMetaData field) { return nullptr; }

    virtual ISbeCompositeDecoder* queryDecoder(ONIXS_FIXENGINE_UNUSED CoderOwnerId owner, ONIXS_FIXENGINE_UNUSED SbeTypeMetaData composite) { return nullptr; }


    virtual ISbeFieldEncoder* queryEncoder(ONIXS_FIXENGINE_UNUSED CoderOwnerId owner, ONIXS_FIXENGINE_UNUSED SbeFieldMetaData field) { return nullptr; }

    virtual ISbeGroupDimensionEncoder* queryGroupDimensionEncoder(ONIXS_FIXENGINE_UNUSED CoderOwnerId owner, ONIXS_FIXENGINE_UNUSED SbeFieldSetMetaData group) { return nullptr; }

    virtual ISbeCompositeEncoder* queryEncoder(ONIXS_FIXENGINE_UNUSED CoderOwnerId owner, ONIXS_FIXENGINE_UNUSED SbeTypeMetaData composite) { return nullptr; }
};

class ONIXS_FIXENGINE_API SbeFieldDecoderOutput
{
public:
    ~SbeFieldDecoderOutput() = default;

    SbeFieldMetaData field() const;

    void setNull();

    void setChar(char value);

    void set(Int16 value);

    void set(UInt16 value);

    void set(Int32 value);

    void set(UInt32 value);

    void set(Int64 value);

    void set(UInt64 value);

    void set(float value);

    void set(double value);

    void set(const void* value, SbeWireSize length);

    void set(const char* value, SbeWireSize length);
private:
    friend SbeFieldDecoderOutput createSbeFieldDecoderOutput(void*);
    SbeFieldDecoderOutput() {}
    SbeFieldDecoderOutput(void*);
    void* details_;
};

class ONIXS_FIXENGINE_API SbeGroupDimensionOutput
{
public:
    ~SbeGroupDimensionOutput() = default;

    SbeFieldSetMetaData group() const;

    void set(SbeWireSize blockLength, SbeWireSize itemCount, SbeWireSize numGroups = UnusedWireSizeValue, SbeWireSize numVarDataFields = UnusedWireSizeValue);
private:
    friend SbeGroupDimensionOutput createSbeGroupDimensionOutput(void*);
    SbeGroupDimensionOutput() {}
    SbeGroupDimensionOutput(void*);
    void* details_;
};

class ONIXS_FIXENGINE_API SbeSpecialCompositeOutput
{
public:
    ~SbeSpecialCompositeOutput() = default;

    SbeTypeMetaData type() const;

    void setMessageHeader(SbeWireSize blockLength, unsigned templateId,
        UInt32 schemaId, unsigned schemaVersion,
        SbeWireSize numGroups = UnusedWireSizeValue,
        SbeWireSize numVarDataFields = UnusedWireSizeValue);
private:
    friend SbeSpecialCompositeOutput createSbeSpecialCompositeOutput(void*);
    SbeSpecialCompositeOutput() {}
    SbeSpecialCompositeOutput(void*);
    void* details_;
};

class ONIXS_FIXENGINE_API ISbeFieldDecoder
{
public:
    virtual ~ISbeFieldDecoder() = default;

    virtual size_t decode(SbeFieldDecoderOutput output, unsigned version, const void* data, size_t available) = 0;
};

class ONIXS_FIXENGINE_API ISbeGroupDimensionDecoder
{
public:
    virtual ~ISbeGroupDimensionDecoder() = default;

    virtual size_t decode(SbeGroupDimensionOutput output, unsigned version, const void* data, size_t available) = 0;
};
 

class ONIXS_FIXENGINE_API ISbeCompositeDecoder
{
public:
    virtual ~ISbeCompositeDecoder() = default;

    virtual size_t decode(SbeSpecialCompositeOutput output, unsigned version, const void* data, size_t available) = 0;
};

class ONIXS_FIXENGINE_API SbeBinaryOutputStream
{
public:
    ~SbeBinaryOutputStream() = default;

    void put(const void* data, SbeWireSize size);
private:
    friend SbeBinaryOutputStream createSbeBinaryOutputStream(void*);
    SbeBinaryOutputStream() {}
    SbeBinaryOutputStream(void*);
    void* details_;
};

class ONIXS_FIXENGINE_API SbeConstFieldAccess
{
public:
    ~SbeConstFieldAccess() = default;

    Tag tag() const;

    SbeFieldMetaData fieldMetaData() const;

    bool present() const;

    bool toString(std::string&) const;

    bool toChar(Char&) const;

    bool toNumber(Int32&) const;

    bool toNumber(UInt32&) const;

    bool toNumber(Int64&) const;

    bool toNumber(UInt64&) const;

    bool toNumber(Double&) const;

    bool toNumber(Decimal&) const;

    bool toTimestamp(Timestamp&,
        TimestampFormat::Enum = TimestampFormat::YYYYMMDDHHMMSSNsec) const;

    bool toTimeSpan(TimeSpan&,
        TimeSpanFormat::Enum = TimeSpanFormat::HHMMSSMsec) const;
protected:
    friend SbeConstFieldAccess createSbeConstFieldAccess(Tag tag, const void*, const void*);
    SbeConstFieldAccess() {}
    SbeConstFieldAccess(Tag tag, const void*, const void*);
    Tag tag_;
    const void* details_;
    const void* details2_;
};

class ONIXS_FIXENGINE_API SbeSpecialCompositeInput
{
public:
    ~SbeSpecialCompositeInput() = default;

    SbeTypeMetaData typeMetaData() const;

    void getMessageHeaderData(UInt32* blockLength = nullptr,
        UInt32* templateId = nullptr,
        UInt32* schemaId = nullptr,
        UInt32* schemaVersion = nullptr,
        UInt32* numOfGroups = nullptr,
        UInt32* numOfVarDataFields = nullptr) const;
protected:
    friend SbeSpecialCompositeInput createSbeSpecialCompositeInput(const void*);
    SbeSpecialCompositeInput() {}
    SbeSpecialCompositeInput(const void*);
    const void* details_;
};

class ONIXS_FIXENGINE_API SbeGroupDimensionInput
{
public:
    ~SbeGroupDimensionInput() = default;

    SbeFieldSetMetaData groupMetaData() const;

    void getGroupDimensionData(SbeWireSize* blockLength = nullptr,
        size_t* itemCount = nullptr,
        SbeWireSize* numGroups = nullptr,
        SbeWireSize* numVarDataFields = nullptr) const;
protected:
    friend SbeGroupDimensionInput createSbeGroupDimensionInput(const void*);
    SbeGroupDimensionInput() {}
    SbeGroupDimensionInput(const void*);
    const void* details_;
};

class ONIXS_FIXENGINE_API ISbeFieldEncoder
{
public:
    virtual ~ISbeFieldEncoder() = default;

    virtual SbeWireSize queryFixedSize(unsigned version) = 0;

    virtual void encode(SbeBinaryOutputStream out, unsigned version, const SbeConstFieldAccess &field) = 0;
};

class ONIXS_FIXENGINE_API ISbeCompositeEncoder
{
public:
    virtual ~ISbeCompositeEncoder() = default;

    virtual void encode(SbeBinaryOutputStream out, unsigned version, SbeSpecialCompositeInput input) = 0;
};

class ONIXS_FIXENGINE_API ISbeGroupDimensionEncoder
{
public:
    virtual ~ISbeGroupDimensionEncoder() = default;

    virtual void encode(SbeBinaryOutputStream out, unsigned version, SbeGroupDimensionInput input) = 0;
};
 
}
}
}