471 lines
10 KiB
C++
471 lines
10 KiB
C++
// 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>
|
|
|
|
ONIXS_CMEMDH_NAMESPACE_BEGIN
|
|
ONIXS_CMEMDH_DATA_PACKING_BEGIN(1)
|
|
|
|
ONIXS_CMEMDH_LTWT_CLASS_DECL(NetFeed);
|
|
|
|
/// Iterator over SBE-encoded messages.
|
|
ONIXS_CMEMDH_LTWT_CLASS
|
|
BinaryMessageIterator
|
|
{
|
|
// Messages are prefixed with message header.
|
|
struct Header
|
|
{
|
|
MessageSize messageSize;
|
|
};
|
|
|
|
const Header* header_;
|
|
const void* end_;
|
|
|
|
void
|
|
validate() const
|
|
{
|
|
if (const
|
|
size_t
|
|
availableSize =
|
|
byteDistance(
|
|
end_, header_))
|
|
{
|
|
if (availableSize < sizeof(Header) ||
|
|
availableSize < header_->messageSize)
|
|
{
|
|
throw std::runtime_error(
|
|
"Not enough data to retrieve SBE message. ");
|
|
}
|
|
}
|
|
}
|
|
|
|
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)
|
|
: header_(
|
|
static_cast
|
|
<const Header*>
|
|
(dataBegin))
|
|
, end_(
|
|
dataEnd)
|
|
{
|
|
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_;
|
|
}
|
|
};
|
|
|
|
/// Collection of encoded messages stored in single packet.
|
|
ONIXS_CMEMDH_LTWT_CLASS BinaryMessages
|
|
{
|
|
// Memory block keeping messages.
|
|
const void* begin_;
|
|
const void* end_;
|
|
|
|
public:
|
|
/// Initializes messages container.
|
|
BinaryMessages(
|
|
const void* messagesBegin,
|
|
const void* messagesEnd)
|
|
: begin_(messagesBegin)
|
|
, end_(messagesEnd)
|
|
{
|
|
}
|
|
|
|
/// Returns iterator pointing to first encoded message.
|
|
BinaryMessageIterator begin() const
|
|
{
|
|
return BinaryMessageIterator(begin_, end_);
|
|
}
|
|
|
|
/// Returns iterator pointing past last encoded message.
|
|
BinaryMessageIterator end() const
|
|
{
|
|
return BinaryMessageIterator(end_, end_);
|
|
}
|
|
};
|
|
|
|
/// Integral type used to identify packets
|
|
/// in a sequence transmitted by MDP.
|
|
typedef
|
|
UInt32
|
|
SequenceNumber;
|
|
|
|
/// Raises exception on ill-formed packet.
|
|
inline
|
|
void
|
|
throwBadPacket(
|
|
size_t packetSize,
|
|
size_t minimalSize)
|
|
{
|
|
std::string error;
|
|
|
|
error +=
|
|
"Cannot construct packet over given buffer "
|
|
"because it doesn't meet requirements on minimal size. "
|
|
"Size of buffer is ";
|
|
|
|
toStr(error, packetSize);
|
|
|
|
error += " byte(s), whereas packet must have at least ";
|
|
|
|
toStr(error, minimalSize);
|
|
|
|
error += " bytes. ";
|
|
|
|
throw std::runtime_error(error);
|
|
}
|
|
|
|
/// Represents CME binary packet containing SBE messages.
|
|
ONIXS_CMEMDH_LTWT_CLASS Packet
|
|
{
|
|
struct Header
|
|
{
|
|
SequenceNumber seqNumber;
|
|
Timestamp sendingTime;
|
|
};
|
|
|
|
const Header* header_;
|
|
size_t size_;
|
|
|
|
public:
|
|
/// Initializes blank instance.
|
|
Packet()
|
|
: header_(NULL)
|
|
, size_(0)
|
|
{
|
|
}
|
|
|
|
/// Initializes binary packet over given buffer.
|
|
///
|
|
/// @throw std::exception if given buffer doesn't
|
|
/// satisfy base requirements on well-formed CME packet.
|
|
Packet(
|
|
const void* data,
|
|
size_t size)
|
|
: header_(
|
|
static_cast
|
|
<const Header*>
|
|
(data))
|
|
, size_(size)
|
|
{
|
|
assert(NULL != header_);
|
|
assert(0 != size_);
|
|
|
|
const
|
|
size_t
|
|
headerSize =
|
|
sizeof(Header);
|
|
|
|
if (size < headerSize)
|
|
{
|
|
throwBadPacket(
|
|
size, headerSize);
|
|
}
|
|
}
|
|
|
|
/// Initializes as a copy of the other instance.
|
|
Packet(
|
|
const Packet& other)
|
|
: header_(other.header_)
|
|
, size_(other.size_)
|
|
{
|
|
}
|
|
|
|
/// Does actually nothing.
|
|
~Packet()
|
|
{
|
|
}
|
|
|
|
/// Packet bytes.
|
|
const void* data() const
|
|
{
|
|
assert(NULL != header_);
|
|
|
|
return static_cast<const void*>(header_);
|
|
}
|
|
|
|
/// Packet size.
|
|
size_t size() const
|
|
{
|
|
return size_;
|
|
}
|
|
|
|
/// Packet sequence number.
|
|
SequenceNumber seqNumber() const
|
|
{
|
|
assert(NULL != header_);
|
|
|
|
return header_->seqNumber;
|
|
}
|
|
|
|
/// Packet sending time.
|
|
const Timestamp& sendingTime() const
|
|
{
|
|
assert(NULL != header_);
|
|
|
|
return header_->sendingTime;
|
|
}
|
|
|
|
/// Returns collection of messages stored by instance.
|
|
BinaryMessages messages() const
|
|
{
|
|
assert(NULL != header_);
|
|
|
|
return
|
|
BinaryMessages(
|
|
header_ + 1,
|
|
advanceByBytes(
|
|
header_, size_));
|
|
}
|
|
|
|
/// Resets the instance to the null state.
|
|
void reset()
|
|
{
|
|
header_ = NULL;
|
|
size_ = 0;
|
|
}
|
|
|
|
/// Re-initializes the instance
|
|
/// to refer to the other content.
|
|
void
|
|
reset(
|
|
const void* data,
|
|
size_t size)
|
|
{
|
|
const
|
|
size_t
|
|
headerSize =
|
|
sizeof(Header);
|
|
|
|
if (data &&
|
|
size >= headerSize)
|
|
{
|
|
header_ =
|
|
static_cast
|
|
<const Header*>
|
|
(data);
|
|
|
|
size_ = size;
|
|
}
|
|
else
|
|
{
|
|
throwBadPacket(
|
|
size, headerSize);
|
|
}
|
|
}
|
|
|
|
/// Re-initializes the instance
|
|
/// as the copy of the other one.
|
|
Packet&
|
|
operator =(
|
|
const Packet& other)
|
|
{
|
|
header_ = other.header_;
|
|
size_ = other.size_;
|
|
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
ONIXS_CMEMDH_LTWT_CLASS
|
|
NetPacket : public Packet
|
|
{
|
|
const NetFeed* source_;
|
|
Timestamp receiveTime_;
|
|
|
|
public:
|
|
/// Initializes as null packet.
|
|
NetPacket()
|
|
: source_(NULL)
|
|
{
|
|
}
|
|
|
|
/// Initializes with primary attributes.
|
|
NetPacket(
|
|
const void* data,
|
|
size_t size)
|
|
: Packet(data, size)
|
|
{
|
|
}
|
|
|
|
/// Initializes as a copy of the other instance.
|
|
NetPacket(
|
|
const NetPacket& other)
|
|
: Packet(
|
|
static_cast
|
|
<const Packet&>
|
|
(other))
|
|
, source_(
|
|
other.source_)
|
|
, receiveTime_(
|
|
other.receiveTime_)
|
|
{
|
|
}
|
|
|
|
/// Does actually nothing.
|
|
~NetPacket()
|
|
{
|
|
}
|
|
|
|
/// Identifies source of the packet.
|
|
const NetFeed& source() const
|
|
{
|
|
assert(NULL != 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();
|
|
source_ = NULL;
|
|
}
|
|
|
|
/// Re-initializes as a copy of the other instance.
|
|
NetPacket&
|
|
operator =(
|
|
const NetPacket& other)
|
|
{
|
|
static_cast<Packet&>(*this) =
|
|
static_cast<const Packet&>(other);
|
|
|
|
source_ = other.source_;
|
|
receiveTime_ = other.receiveTime_;
|
|
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
/// Alias for a type keeping collection
|
|
/// of packet-related attributes.
|
|
typedef NetPacket PacketArgs;
|
|
|
|
ONIXS_CMEMDH_DATA_PACKING_END
|
|
ONIXS_CMEMDH_NAMESPACE_END
|