MessagePtr.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/CboeCFE/Trading/BOE/Compiler.h>

#if ONIXS_BATS_BOE_HAS_GATEWAY_EMULATOR

#include <memory>
#include <utility>

#include <OnixS/CboeCFE/Trading/BOE/ABI.h>
#include <OnixS/CboeCFE/Trading/BOE/BinaryMessage.h>
#include <OnixS/CboeCFE/Trading/BOE/Enumerations.h>
#include <OnixS/CboeCFE/Trading/BOE/Testing/MessageTypeTraits.h>

namespace OnixS {
namespace CboeCFE {
namespace Trading {
namespace BOE {
namespace Testing {

ONIXS_CBOE_CFE_BOE_API
ONIXS_BATS_BOE_NORETURN
void throwWrongType(MessageType::Enum expected, MessageType::Enum provided);

template<class Message>
Message typify(const BinaryMessage& message)
{
    return Message(message.binary(), message.binarySize());
}

/// Message container.
template <typename Message>
class MessagePtr
{
public:
    using Container = std::shared_ptr<UInt8>;

    /// Creates from the given memory block.
    MessagePtr(Container&&, MessageSize, MessageType::Enum, SeqNumber);

    /// Create from another type.
    template <class AnotherType>
    explicit MessagePtr(const MessagePtr<AnotherType>& rhs)
        : type_(rhs.type_)
        , size_(rhs.size_)
        , container_(rhs.container_)
        , message_()
        , seqNumber_(rhs.seqNumber_)
    {
        fromAnotherType(rhs);
    }

    /// Creates from the given type.
    template <class AnotherType>
    explicit MessagePtr(MessagePtr<AnotherType>&& rhs)
        : type_(rhs.type_)
        , size_(rhs.size_)
        , container_(std::move(rhs.container_))
        , message_()
        , seqNumber_(rhs.seqNumber_)
    {
        fromAnotherType(rhs);
    }

    /// Creates an empty message container.
    MessagePtr()
      : type_(MessageType::Undefined)
      , size_(0)
      , container_()
      , message_()
      , seqNumber_(SeqNumberTraits::InvalidValue)
    {
    }

    MessagePtr(const MessagePtr&) = default;
    MessagePtr& operator=(const MessagePtr&) = default;

    ///
    MessagePtr(MessagePtr&& rhs) noexcept
    {
        rhs.swap(*this);
        rhs.reset();
    }

    ///
    MessagePtr& operator=(MessagePtr&& rhs) noexcept
    {
        if (&rhs == this)
            return *this;

        rhs.swap(*this);
        rhs.reset();

        return *this;
    }

    ///
    bool valid() const noexcept
    {
        return static_cast<bool>(message_);
    }

    /// \return message sequence number
    SeqNumber seqNumber() const noexcept
    {
        return seqNumber_;
    }

    ///
    void swap(MessagePtr& rhs) noexcept
    {
        std::swap(rhs.type_, type_);
        std::swap(rhs.size_, size_);
        std::swap(rhs.container_, container_);
        std::swap(rhs.message_, message_);
        std::swap(rhs.seqNumber_, seqNumber_);
    }

    ///
    Message* operator->() noexcept
    {
        assert(valid());
        return &message_;
    }

    ///
    const Message* operator->() const noexcept
    {
        assert(valid());
        return &message_;
    }

    ///
    Message& operator*() noexcept
    {
        return message_;
    }

    ///
    const Message& operator*() const noexcept
    {
        return message_;
    }

    /// \return the underlying message.
    Message& message() noexcept
    {
        assert(valid());
        return message_;
    }

    /// \return the underlying message.
    const Message& message() const noexcept
    {
        assert(valid());
        return message_;
    }

    ///
    operator Message() noexcept
    {
        return message();
    }

    ///
    operator const Message() const noexcept
    {
        return message();
    }

    /// \return the underlying buffer.
    UInt8* buf() noexcept
    {
        return container_.get();
    }

    /// Resets the message.
    void reset() noexcept
    {
        type_ = MessageType::Undefined;
        size_ = 0;
        container_.reset();
        message_ = Message();
    }

    /// \return the human-readable presentation.
    std::string toString() const
    {
        return toStr(message_);
    }

    /// \return message type
    MessageType::Enum getType() const noexcept
    {
        return type_;
    }

    Container release()
    {
        Container c = container_;
        reset();
        return c;
    }

private:
    template<typename MessageT>
    static typename MessageType::Enum getMessageType()
    {
        return MessageT::type();
    }

    template <class AnotherType>
    void fromAnotherType(const MessagePtr<AnotherType>& rhs)
    {
        if(getType() != getMessageType<Message>())
            throwWrongType(getMessageType<Message>(), getType());

        message_ = typify<Message>(rhs);
    }

private:
    MessageType::Enum type_;
    MessageSize size_;
    Container container_;
    Message message_;
    SeqNumber seqNumber_;

    template<class T> friend class MessagePtr;
};

template<>
inline MessagePtr<BinaryMessage>::MessagePtr(Container&& container, MessageSize size, MessageType::Enum type, SeqNumber seqNumber)
    : type_(type)
    , size_(size)
    , container_(std::move(container))
    , message_(container_.get(), size_)
    , seqNumber_(seqNumber)
{
}

/// Tries to cast to another type.
template <BOE::MessageType::Enum AnotherType>
MessagePtr<typename MessageTypeTraits<AnotherType>::MessageType> cast(const MessagePtr<BinaryMessage>& ptr)
{
    static_assert(std::is_base_of<BinaryMessage, typename MessageTypeTraits<AnotherType>::MessageType>::value, "");
    return MessagePtr<typename MessageTypeTraits<AnotherType>::MessageType>(ptr);
}

using MessageBasePtr = MessagePtr<BinaryMessage>;
using NewOrderV2Ptr = MessagePtr<ConstantNewOrderV2>;
using ModifyOrderPtr = MessagePtr<ConstantModifyOrder>;
using CancelOrderPtr = MessagePtr<ConstantCancelOrder>;
using MassCancelOrderPtr = MessagePtr<ConstantMassCancelOrder>;
using PurgeOrdersPtr = MessagePtr<ConstantPurgeOrders>;
using QuoteUpdatePtr = MessagePtr<ConstantQuoteUpdate>;
using ResetRiskPtr = MessagePtr<ConstantResetRisk>;
using LoginRequestPtr = MessagePtr<ConstantLoginRequest>;
using LogoutRequestPtr = MessagePtr<ConstantLogoutRequest>;
using ClientHeartbeatPtr = MessagePtr<ConstantClientHeartbeat>;

typedef MessageBasePtr::Container PacketContainer;

}}}}}

#endif