Packet.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 <cassert>
#include <stdexcept>

#include <OnixS/CME/MDH/Time.h>
#include <OnixS/CME/MDH/Integral.h>

#include <OnixS/CME/MDH/BinaryMessage.h>
#include <OnixS/CME/MDH/PacketTraits.h>

ONIXS_CMEMDH_NAMESPACE_BEGIN
ONIXS_CMEMDH_DATA_PACKING_BEGIN(1)

ONIXS_CMEMDH_LTWT_CLASS_DECL(NetFeed);
ONIXS_CMEMDH_LTWT_CLASS_DECL(Packet);

/// Raises exception on ill-formed message.
ONIXS_CMEMDH_EXPORTED
void throwBadMessage(const Packet* packet);

/// Iterator over SBE-encoded messages.
class ONIXS_CMEMDH_LTWT BinaryMessageIterator
{
public:
    // Identifies iterator category.
    typedef std::forward_iterator_tag iterator_category;

    /// Establishes instance difference type.
    typedef ptrdiff_t difference_type;

    /// Defines value type.
    typedef const BinaryMessage value_type;

    /// Defines pointer to a value type.
    typedef value_type* pointer;

    /// Defines reference to a value type.
    typedef value_type& reference;

    /// Constructs encoded message iterator from raw data pointers.
    ///
    /// @throw runtime_error in case when raw data pointers
    /// cannot be casted to valid encoded message iterator.
    BinaryMessageIterator(const void* dataBegin, const void* dataEnd, const Packet* packet)
        : header_(static_cast<const Header*>(dataBegin))
        , end_(dataEnd)
        , packet_(packet)
    {
        assert(dataBegin <= dataEnd);

        validate();
    }

    /// Gets reference to encoded message.
    ///
    /// @warning Behavior is undefined in case
    /// when iterator points to the packet end.
    BinaryMessage message() const
    {
        assert(header_ != end_);

        return BinaryMessage(header_ + 1, header_->messageSize - sizeof(Header));
    }

    /// Dereferences encoded message.
    BinaryMessage operator*() const
    {
        return message();
    }

    /// Advances iterator to next message.
    /// @throw runtime_error in case when iteration is not possible.
    BinaryMessageIterator& operator++()
    {
        header_ = advanceByBytes(header_, header_->messageSize);

        validate();

        return *this;
    }

    /// Checks whether two iterators are equal.
    bool operator==(const BinaryMessageIterator& other) const
    {
        return header_ == other.header_;
    }

    /// Checks whether two iterators are not equal.
    bool operator!=(const BinaryMessageIterator& other) const
    {
        return header_ != other.header_;
    }

private:
    // Messages are prefixed with message header.
    struct Header
    {
        MessageSize messageSize;
    };

    const Header* header_;
    const void* end_;
    const Packet* packet_;

    void validate() const
    {
        const size_t availableSize = byteDistance(end_, header_);

        if ONIXS_CMEMDH_LIKELY(availableSize != 0)
            if ONIXS_CMEMDH_UNLIKELY(availableSize < sizeof(Header) || availableSize < header_->messageSize)
                throwBadMessage(packet_);
    }
};

/// Collection of encoded messages stored in single packet.
class ONIXS_CMEMDH_LTWT BinaryMessages
{
public:
    /// Initializes messages container.
    BinaryMessages(const void* messagesBegin, const void* messagesEnd, const Packet* packet = ONIXS_CMEMDH_NULLPTR)
        : begin_(messagesBegin)
        , end_(messagesEnd)
        , packet_(packet)
    {
    }

    /// Returns iterator pointing to first encoded message.
    BinaryMessageIterator begin() const
    {
        return BinaryMessageIterator(begin_, end_, packet_);
    }

    /// Returns iterator pointing past last encoded message.
    BinaryMessageIterator end() const
    {
        return BinaryMessageIterator(end_, end_, packet_);
    }

private:
    // Memory block keeping messages.
    const void* begin_;
    const void* end_;
    const Packet* packet_;
};

/// Raises exception on ill-formed packet.
ONIXS_CMEMDH_EXPORTED
void throwBadPacket(PacketSize packetSize, PacketSize minimalSize, const void* data);

/// Used to identify the necessity to omit
/// verification where that's applicable.
struct ONIXS_CMEMDH_LTWT NoVerify
{};

/// Represents CME binary packet containing SBE messages.
class ONIXS_CMEMDH_LTWT Packet
{
public:
    /// Initializes blank instance.
    Packet()
        : header_(ONIXS_CMEMDH_NULLPTR)
        , size_(0)
    {
    }

    /// Initializes binary packet over the given buffer.
    ///
    /// @throw std::exception if given buffer doesn't
    /// satisfy base requirements on well-formed CME packet.
    Packet(const void* data, PacketSize size)
        : header_(static_cast<const Header*>(data))
        , size_(size)
    {
        assert(ONIXS_CMEMDH_NULLPTR != header_);
        assert(0 != size_);

        const PacketSize headerSize = sizeof(Header);

        if ONIXS_CMEMDH_UNLIKELY(size < headerSize)
            throwBadPacket(size, headerSize, data);
    }

    /// Initializes binary packet over the given buffer.
    /// Verification of the incoming content is omitted.
    Packet(const void* data, PacketSize size, const NoVerify&)
        : header_(static_cast<const Header*>(data))
        , size_(size)
    {
    }

    /// Initializes as a copy of the other instance.
    Packet(const Packet& other)
        : header_(other.header_)
        , size_(other.size_)
    {
    }

    /// Does actually nothing.
    ~Packet() {}

    /// Indicates whether the given
    /// instance points to a valid packet.
    operator bool() const
    {
        return 0 != size_;
    }

    /// Packet bytes.
    const void* data() const
    {
        assert(ONIXS_CMEMDH_NULLPTR != header_);

        return static_cast<const void*>(header_);
    }

    /// Packet size.
    PacketSize size() const
    {
        return size_;
    }

    /// Packet sequence number.
    SequenceNumber seqNumber() const
    {
        assert(ONIXS_CMEMDH_NULLPTR != header_);

        return header_->seqNumber;
    }

    /// Packet sending time.
    const Timestamp& sendingTime() const
    {
        assert(ONIXS_CMEMDH_NULLPTR != header_);

        return header_->sendingTime;
    }

    /// Returns collection of messages stored by instance.
    BinaryMessages messages() const
    {
        assert(ONIXS_CMEMDH_NULLPTR != header_);

        return BinaryMessages(header_ + 1, advanceByBytes(header_, size_), this);
    }

    /// Resets the instance to the null state.
    void reset()
    {
        header_ = ONIXS_CMEMDH_NULLPTR;
        size_ = 0;
    }

    /// Re-initializes the instance
    /// to refer to the other content.
    void reset(const void* data, PacketSize size)
    {
        const PacketSize headerSize = sizeof(Header);

        if ONIXS_CMEMDH_UNLIKELY(!data || size < headerSize)
            throwBadPacket(size, headerSize, data);

        header_ = static_cast<const Header*>(data);
        size_ = size;
    }

    /// Re-initializes the instance
    /// to refer to the other content.
    void reset(const void* data, PacketSize size, const NoVerify&)
    {
        header_ = static_cast<const Header*>(data);

        size_ = size;
    }

    /// Re-initializes the instance
    /// as the copy of the other one.
    Packet& operator=(const Packet& other)
    {
        header_ = other.header_;
        size_ = other.size_;

        return *this;
    }

private:
    struct Header
    {
        SequenceNumber seqNumber;
        Timestamp sendingTime;
    };

    const Header* header_;
    PacketSize size_;
};

ONIXS_CMEMDH_EXPORTED
void toStr(std::string& str, const Packet& packet);

inline std::string toStr(const Packet& packet)
{
    std::string str;
    toStr(str, packet);
    return str;
}

class ONIXS_CMEMDH_LTWT NetPacket : public Packet
{
public:
    /// Initializes as null packet.
    NetPacket()
        : source_(ONIXS_CMEMDH_NULLPTR)
    {
    }

    /// Initializes with primary attributes.
    NetPacket(const void* data, PacketSize size)
        : Packet(data, size)
        , source_(ONIXS_CMEMDH_NULLPTR)
    {
    }

    /// Initializes as a copy of the other instance.
    NetPacket(const NetPacket& other)
        : Packet(static_cast<const Packet&>(other))
        , receiveTime_(other.receiveTime_)
        , source_(other.source_)
    {
    }

    /// Does actually nothing.
    ~NetPacket() {}

    /// Identifies source of the packet.
    const NetFeed& source() const
    {
        assert(ONIXS_CMEMDH_NULLPTR != source_);

        return *source_;
    }

    /// Updates packet source attribute.
    void source(const NetFeed& source)
    {
        source_ = &source;
    }

    /// Data reception time (if applicable).
    const Timestamp& receiveTime() const
    {
        return receiveTime_;
    }

    /// Updates receive time attribute.
    void receiveTime(const Timestamp& receiveTime)
    {
        receiveTime_ = receiveTime;
    }

    /// Resets the instances to the blank state.
    void reset()
    {
        Packet::reset();

        receiveTime_ = Timestamp();

        source_ = ONIXS_CMEMDH_NULLPTR;
    }

    /// Re-initializes as a copy of the other instance.
    NetPacket& operator=(const NetPacket& other)
    {
        static_cast<Packet&>(*this) = static_cast<const Packet&>(other);

        receiveTime_ = other.receiveTime_;

        source_ = other.source_;

        return *this;
    }

private:
    Timestamp receiveTime_;
    const NetFeed* source_;
};

/// Alias for a type keeping collection
/// of packet-related attributes.
typedef NetPacket PacketArgs;

ONIXS_CMEMDH_DATA_PACKING_END
ONIXS_CMEMDH_NAMESPACE_END