Composites.h

Go to the documentation of this file.

// 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.
//
 
#pragma once
 
#include <OnixS/ICE/BOE/ABI.h>
 
#include <OnixS/ICE/BOE/messaging/Memory.h>
#include <OnixS/ICE/BOE/messaging/Decimal.h>
#include <OnixS/ICE/BOE/messaging/Utils.h>
#include <OnixS/ICE/BOE/messaging/Fields.h>
#include <OnixS/ICE/BOE/messaging/SbeOptional.h>
 
ONIXS_ICEBOE_MESSAGING_NAMESPACE_BEGIN
 
template <typename Callable>
ONIXS_ICEBOE_FORCEINLINE
auto convert(typename ArgType<Callable>::type value) noexcept(noexcept(Callable::Nothrow))
    -> decltype(std::declval<Callable>()(std::declval<typename ArgType<Callable>::type>()))
{
    return Callable{}(value);
}
 
template <typename NullValue, typename Callable>
auto convert(typename ArgType<Callable>::type value, OptionalTag) noexcept(noexcept(Callable::Nothrow))
    -> SbeOptionalConverted<decltype(std::declval<Callable>()(std::declval<typename ArgType<Callable>::type>()))>
{
    using ReturnType = decltype(std::declval<Callable>()(std::declval<typename ArgType<Callable>::type>()));
 
    if(value == NullValue::value())
        return SbeOptionalConverted<ReturnType>::null();
 
    return SbeOptionalConverted<ReturnType>(Callable{}(value));
}
 
ONIXS_ICEBOE_DATA_PACKING_BEGIN(1)
 

class MessageHeader
{
public:
    enum { Size = 21 };

    typedef UInt16 BlockLength;

    typedef UInt16 TemplateId;

    typedef UInt16 SchemaId;

    typedef UInt16 Version;

    typedef UInt32 SequenceId;

    typedef UInt64 UTCTimestamp;

    ONIXS_ICEBOE_NODISCARD
    BlockLength blockLength() const noexcept
    {
        return blockLength_;
    }

    void blockLength(BlockLength value) noexcept
    {
        blockLength_ = value;
    }

    ONIXS_ICEBOE_NODISCARD
    TemplateId templateId() const noexcept
    {
        return templateId_;
    }

    void templateId(TemplateId value) noexcept
    {
        templateId_ = value;
    }

    ONIXS_ICEBOE_NODISCARD
    SchemaId schemaId() const noexcept
    {
        return schemaId_;
    }

    void schemaId(SchemaId value) noexcept
    {
        schemaId_ = value;
    }

    ONIXS_ICEBOE_NODISCARD
    Version version() const noexcept
    {
        return version_;
    }

    void version(Version value) noexcept
    {
        version_ = value;
    }

    ONIXS_ICEBOE_NODISCARD
    SequenceId sequenceId() const noexcept
    {
        return sequenceId_;
    }

    void sequenceId(SequenceId value) noexcept
    {
        sequenceId_ = value;
    }

    ONIXS_ICEBOE_NODISCARD
    Timestamp sendTime() const noexcept(ticksToTimestamp::Nothrow)
    {
        return convert<ticksToTimestamp>(sendTime_);
    }

    void sendTime(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        sendTime_ = convert<timestampToTicks>(value);
    }

    ONIXS_ICEBOE_NODISCARD
    HeaderFlags headerFlags() const noexcept
    {
        return headerFlags_;
    }

    void headerFlags(HeaderFlags value) noexcept
    {
        headerFlags_ = value;
    }
 
private:
    BlockLength blockLength_;
    TemplateId templateId_;
    SchemaId schemaId_;
    Version version_;
    SequenceId sequenceId_;
    UTCTimestamp sendTime_;
    HeaderFlags headerFlags_;
};
 

struct Data
{
public:
    enum { Size = 2 };

    typedef UInt16 Length;

    typedef UInt8 VarData;

    ONIXS_ICEBOE_NODISCARD
    Length length() const noexcept
    {
        return length_;
    }

    void length(Length value) noexcept
    {
        length_ = value;
    }

    ONIXS_ICEBOE_NODISCARD
    StrRef varData() const noexcept
    {
        return StrRef(reinterpret_cast<const Char*>(this) + Size, length());
    }

    void varData(StrRef value) noexcept
    {
        length(static_cast<Length>(value.size()));
        if(value.data())
            std::memcpy(reinterpret_cast<Char*>(this) + Size, value.data(), value.size());
    }

    ONIXS_ICEBOE_NODISCARD
    Length binarySize() const noexcept
    {
        return Size + length();
    }
 
private:
    Length length_;
};
 

struct VarString8
{
public:
    enum { Size = 1 };

    typedef UInt8 Length;

    typedef Char VarData;

    ONIXS_ICEBOE_NODISCARD
    Length length() const noexcept
    {
        return length_;
    }

    void length(Length value) noexcept
    {
        length_ = value;
    }

    ONIXS_ICEBOE_NODISCARD
    StrRef varData() const noexcept
    {
        return StrRef(reinterpret_cast<const Char*>(this) + Size, length());
    }

    void varData(StrRef value) noexcept
    {
        length(static_cast<Length>(value.size()));
        if(value.data())
            std::memcpy(reinterpret_cast<Char*>(this) + Size, value.data(), value.size());
    }

    ONIXS_ICEBOE_NODISCARD
    Length binarySize() const noexcept
    {
        return Size + length();
    }
 
private:
    Length length_;
};
 

struct VarString16
{
public:
    enum { Size = 2 };

    typedef UInt16 Length;

    typedef Char VarData;

    ONIXS_ICEBOE_NODISCARD
    Length length() const noexcept
    {
        return length_;
    }

    void length(Length value) noexcept
    {
        length_ = value;
    }

    ONIXS_ICEBOE_NODISCARD
    StrRef varData() const noexcept
    {
        return StrRef(reinterpret_cast<const Char*>(this) + Size, length());
    }

    void varData(StrRef value) noexcept
    {
        length(static_cast<Length>(value.size()));
        if(value.data())
            std::memcpy(reinterpret_cast<Char*>(this) + Size, value.data(), value.size());
    }

    ONIXS_ICEBOE_NODISCARD
    Length binarySize() const noexcept
    {
        return Size + length();
    }
 
private:
    Length length_;
};
 

class GroupSizeEncoding
{
public:
    enum { Size = 4 };

    typedef UInt16 BlockLength;

    typedef UInt16 NumInGroup;

    ONIXS_ICEBOE_NODISCARD
    std::string
    toString() const;

    ONIXS_ICEBOE_NODISCARD
    BlockLength blockLength() const noexcept
    {
        return blockLength_;
    }

    void blockLength(BlockLength value) noexcept
    {
        blockLength_ = value;
    }

    ONIXS_ICEBOE_NODISCARD
    NumInGroup numInGroup() const noexcept
    {
        return numInGroup_;
    }

    void numInGroup(NumInGroup value) noexcept
    {
        numInGroup_ = value;
    }
 
private:
    BlockLength blockLength_;
    NumInGroup numInGroup_;
};
 

class MaxOneGroupSizeEncoding
{
public:
    enum { Size = 4 };

    typedef UInt16 BlockLength;

    typedef UInt16 NumInGroup;

    ONIXS_ICEBOE_NODISCARD
    std::string
    toString() const;

    ONIXS_ICEBOE_NODISCARD
    BlockLength blockLength() const noexcept
    {
        return blockLength_;
    }

    void blockLength(BlockLength value) noexcept
    {
        blockLength_ = value;
    }

    ONIXS_ICEBOE_NODISCARD
    NumInGroup numInGroup() const noexcept
    {
        return numInGroup_;
    }

    void numInGroup(NumInGroup value) noexcept
    {
        numInGroup_ = value;
    }
 
private:
    BlockLength blockLength_;
    NumInGroup numInGroup_;
};
 
 
typedef MessageHeader MessageHeaderBuilder;
 
ONIXS_ICEBOE_DATA_PACKING_END

class OrderExecID
{
public:
    enum { Size = 20 };

    typedef Int64 SystemID;

    typedef Int32 SystemSequenceID;

    typedef UInt64 UTCTimestamp;

    constexpr
    OrderExecID() noexcept
      : systemId_(0),
        systemSequenceId_(0),
        transactTime_(0)
    {
    }

    OrderExecID(SystemID systemId, SystemSequenceID systemSequenceId, Timestamp transactTime) noexcept(timestampToTicks::Nothrow)
      : systemId_(systemId),
        systemSequenceId_(systemSequenceId),
        transactTime_(convert<timestampToTicks>(transactTime))
    {
    }

    constexpr
    OrderExecID(SystemID systemId, SystemSequenceID systemSequenceId, UTCTimestamp transactTime) noexcept
      : systemId_(systemId),
        systemSequenceId_(systemSequenceId),
        transactTime_(transactTime)
    {
    }

    ONIXS_ICEBOE_NODISCARD
    std::string
    toString() const;

    struct MemberTraits
    {
        enum { Count = 3 };
 
        typedef SystemID FirstArgType;
 
        typedef SystemSequenceID SecondArgType;
 
        typedef UTCTimestamp ThirdArgType;
    };

    void serialize(void* addr) const noexcept
    {
        assert(addr);
 
        std::memcpy(addr, &systemId_, sizeof(systemId_));
        addr = advanceByBytes(addr, sizeof(systemId_));
 
        std::memcpy(addr, &systemSequenceId_, sizeof(systemSequenceId_));
        addr = advanceByBytes(addr, sizeof(systemSequenceId_));
 
        std::memcpy(addr, &transactTime_, sizeof(transactTime_));
    }

    ONIXS_ICEBOE_NODISCARD
    SystemID systemId() const noexcept
    {
        return systemId_;
    }

    void systemId(SystemID value) noexcept
    {
        systemId_ = value;
    }

    ONIXS_ICEBOE_NODISCARD
    SystemSequenceID systemSequenceId() const noexcept
    {
        return systemSequenceId_;
    }

    void systemSequenceId(SystemSequenceID value) noexcept
    {
        systemSequenceId_ = value;
    }

    ONIXS_ICEBOE_NODISCARD
    Timestamp transactTime() const noexcept(ticksToTimestamp::Nothrow)
    {
        return convert<ticksToTimestamp>(transactTime_);
    }

    void transactTime(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        transactTime_ = convert<timestampToTicks>(value);
    }

    ONIXS_ICEBOE_NODISCARD
    bool operator==(const OrderExecID& other) const noexcept
    {
        return
            (this->systemId_ == other.systemId_) &&
            (this->systemSequenceId_ == other.systemSequenceId_) &&
            (this->transactTime_ == other.transactTime_);
    }

    ONIXS_ICEBOE_NODISCARD
    bool operator!=(const OrderExecID& other) const noexcept
    {
        return !(*this == other);
    }
 
private:
    SystemID systemId_;
    SystemSequenceID systemSequenceId_;
    UTCTimestamp transactTime_;
};
 

class OriginalOrderID
{
public:
    enum { Size = 16 };

    typedef Int64 OriginalSystemID;

    typedef
    IntegralConstant<Int64, -9223372036854775807LL-1>
    NullOriginalSystemID;

    typedef UInt64 UTCTimestamp;

    typedef
    IntegralConstant<UInt64, 0ULL>
    NullUTCTimestamp;

    constexpr
    OriginalOrderID() noexcept
      : originalSystemId_(NullOriginalSystemID::value()),
        originalCreationTimestamp_(NullUTCTimestamp::value())
    {
    }

    OriginalOrderID(OriginalSystemID originalSystemId, Timestamp originalCreationTimestamp) noexcept(timestampToTicks::Nothrow)
      : originalSystemId_(originalSystemId),
        originalCreationTimestamp_(convert<timestampToTicks>(originalCreationTimestamp))
    {
    }

    constexpr
    OriginalOrderID(OriginalSystemID originalSystemId, UTCTimestamp originalCreationTimestamp) noexcept
      : originalSystemId_(originalSystemId),
        originalCreationTimestamp_(originalCreationTimestamp)
    {
    }

    ONIXS_ICEBOE_NODISCARD
    std::string
    toString() const;

    struct MemberTraits
    {
        enum { Count = 2 };
 
        typedef OriginalSystemID FirstArgType;
 
        typedef UTCTimestamp SecondArgType;
    };

    void serialize(void* addr) const noexcept
    {
        assert(addr);
 
        std::memcpy(addr, &originalSystemId_, sizeof(originalSystemId_));
        addr = advanceByBytes(addr, sizeof(originalSystemId_));
 
        std::memcpy(addr, &originalCreationTimestamp_, sizeof(originalCreationTimestamp_));
    }

    ONIXS_ICEBOE_NODISCARD
    OriginalSystemID originalSystemId() const noexcept
    {
        return originalSystemId_;
    }

    void originalSystemId(OriginalSystemID value) noexcept
    {
        originalSystemId_ = value;
    }
 
    void originalSystemId(NullOpt) noexcept
    {
        originalSystemId_ = NullOriginalSystemID();
    }

    auto originalCreationTimestamp() const noexcept(ticksToTimestamp::Nothrow)
    {
        return convert<NullUTCTimestamp, ticksToTimestamp>(
            originalCreationTimestamp_,
            optional);
    }

    void originalCreationTimestamp(Timestamp value) noexcept(timestampToTicks::Nothrow)
    {
        originalCreationTimestamp_ = convert<timestampToTicks>(value);
    }
 
    void originalCreationTimestamp(NullOpt) noexcept
    {
        originalCreationTimestamp_ = NullUTCTimestamp();
    }

    ONIXS_ICEBOE_NODISCARD
    bool
    operator==(
        const OriginalOrderID& other) const noexcept;

    ONIXS_ICEBOE_NODISCARD
    bool operator!=(const OriginalOrderID& other) const noexcept
    {
        return !(*this == other);
    }
 
private:
    OriginalSystemID originalSystemId_;
    UTCTimestamp originalCreationTimestamp_;
};
 

struct NullOriginalOrderID
{
    typedef OriginalOrderID Value;

    ONIXS_ICEBOE_NODISCARD
    bool operator ==(const Value& other) const noexcept
    {
        return (
           OriginalOrderID::NullOriginalSystemID() ==
           other.originalSystemId());
    }

    ONIXS_ICEBOE_NODISCARD
    bool operator !=(const Value& other) const noexcept
    {
        return !(*this == other);
    }

    constexpr
    operator Value() const noexcept
    {
        return Value();
    }

    constexpr
    Value operator()() const noexcept
    {
        return Value();
    }

    constexpr
    static Value value() noexcept
    {
        return Value();
    }
};
 
inline bool OriginalOrderID::operator==(const OriginalOrderID& other) const noexcept
{
    if((NullOriginalOrderID() == *this) &&
            (NullOriginalOrderID() == other))
        return true;
 
    return
        (this->originalSystemId_ == other.originalSystemId_) &&
        (this->originalCreationTimestamp_ == other.originalCreationTimestamp_);
}
 
 
ONIXS_ICEBOE_MESSAGING_NAMESPACE_END