1188 lines
26 KiB
C++
1188 lines
26 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/String.h>
|
|
#include <OnixS/CME/MDH/Memory.h>
|
|
|
|
#include <OnixS/CME/MDH/Composites.h>
|
|
#include <OnixS/CME/MDH/SchemaTraits.h>
|
|
|
|
ONIXS_CMEMDH_NAMESPACE_BEGIN
|
|
|
|
/// Exposes base services to access fields stored in
|
|
/// SBE-encoded block of memory. Class represents an
|
|
/// abstraction, instance construction available through
|
|
/// descendants implementing actual access to encoded data.
|
|
template
|
|
<
|
|
class Block,
|
|
class BlockSize
|
|
>
|
|
class BinaryFields
|
|
{
|
|
/// Instance of block providing
|
|
/// actual access to encoded data.
|
|
const Block& block() const
|
|
{
|
|
return *static_cast<const Block*>(this);
|
|
}
|
|
|
|
protected:
|
|
/// Initializes blank instance.
|
|
BinaryFields()
|
|
{
|
|
}
|
|
|
|
/// Cleans everything up.
|
|
~BinaryFields()
|
|
{
|
|
}
|
|
|
|
/// Returns value of a field by its offset.
|
|
template
|
|
<
|
|
class FieldValue
|
|
>
|
|
const
|
|
FieldValue&
|
|
ordinary(
|
|
BlockSize offset) const
|
|
{
|
|
assert(
|
|
block().bodySize() >=
|
|
(offset + sizeof(FieldValue)));
|
|
|
|
const void*
|
|
const fieldValue =
|
|
advanceByBytes(
|
|
block().body(),
|
|
offset);
|
|
|
|
return
|
|
*static_cast
|
|
<const FieldValue*>
|
|
(fieldValue);
|
|
}
|
|
|
|
/// Provides access to a value of
|
|
/// an optional field by its offset.
|
|
///
|
|
/// Returned result indicates whether field is
|
|
/// present in given field block and its value
|
|
/// was copied into a given parameter-variable.
|
|
template
|
|
<
|
|
class FieldValue,
|
|
class NullValue
|
|
>
|
|
bool
|
|
ordinary(
|
|
FieldValue& value,
|
|
BlockSize offset,
|
|
const NullValue& null) const
|
|
{
|
|
const FieldValue& fieldValue =
|
|
ordinary<FieldValue>(offset);
|
|
|
|
if (null != fieldValue)
|
|
{
|
|
value = fieldValue;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// Provides access to a value of
|
|
/// an optional field by its offset.
|
|
///
|
|
/// Returned result indicates whether field is
|
|
/// present in given field block and its value
|
|
/// was copied into a given parameter-variable.
|
|
///
|
|
/// Field may not be present in earlier versions
|
|
/// of binary message and thus its value may not be
|
|
/// available. For this reason, parameter indicating
|
|
/// version of data assumed is required to access
|
|
/// the field.
|
|
template
|
|
<
|
|
class FieldValue,
|
|
class NullValue
|
|
>
|
|
bool
|
|
ordinary(
|
|
FieldValue& value,
|
|
BlockSize offset,
|
|
const NullValue& null,
|
|
SchemaVersion since) const
|
|
{
|
|
return (
|
|
since <= block().version()
|
|
&&
|
|
ordinary(value, offset, null)
|
|
);
|
|
}
|
|
|
|
/// Returns value of a field by its offset.
|
|
///
|
|
/// Given function serves as specialization of
|
|
/// general case for fields of enumeration type.
|
|
template
|
|
<
|
|
class Enumeration
|
|
>
|
|
typename
|
|
Enumeration::Enum
|
|
enumeration(
|
|
BlockSize offset) const
|
|
{
|
|
typedef
|
|
typename
|
|
Enumeration::Base
|
|
Base;
|
|
|
|
typedef
|
|
typename
|
|
Enumeration::Enum
|
|
Enum;
|
|
|
|
return
|
|
static_cast<Enum>(
|
|
ordinary<Base>(offset));
|
|
}
|
|
|
|
/// Provides access to value of
|
|
/// an optional field by its offset.
|
|
///
|
|
/// Given function serves as specialization of
|
|
/// general case for fields of enumeration type.
|
|
template
|
|
<
|
|
class Enumeration,
|
|
class NullValue
|
|
>
|
|
bool
|
|
enumeration(
|
|
typename
|
|
Enumeration::Enum& value,
|
|
BlockSize offset,
|
|
const NullValue& null) const
|
|
{
|
|
typedef
|
|
typename
|
|
Enumeration::Base
|
|
Base;
|
|
|
|
typedef
|
|
typename
|
|
Enumeration::Enum
|
|
Enum;
|
|
|
|
const Base& fieldValue =
|
|
ordinary<Base>(offset);
|
|
|
|
if (null != fieldValue)
|
|
{
|
|
value = static_cast<Enum>(fieldValue);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// Provides access to value of
|
|
/// an optional field by its offset.
|
|
///
|
|
/// Given function serves as specialization of
|
|
/// general case for fields of enumeration type.
|
|
template
|
|
<
|
|
class Enumeration,
|
|
class NullValue
|
|
>
|
|
bool
|
|
enumeration(
|
|
typename
|
|
Enumeration::Enum& value,
|
|
BlockSize offset,
|
|
const NullValue& null,
|
|
SchemaVersion since) const
|
|
{
|
|
return (
|
|
since <= block().version()
|
|
&&
|
|
enumeration(value, offset, null)
|
|
);
|
|
}
|
|
|
|
/// Returns value of a field by its
|
|
/// offset converted into a decimal.
|
|
template
|
|
<
|
|
class FieldValue
|
|
>
|
|
Decimal
|
|
decimal(
|
|
BlockSize offset) const
|
|
{
|
|
return Decimal
|
|
(
|
|
ordinary
|
|
<FieldValue>
|
|
(offset)
|
|
);
|
|
}
|
|
|
|
/// Provides access to a value of
|
|
/// an optional field by its offset.
|
|
/// The result is converted into decimal.
|
|
///
|
|
/// Returned result indicates whether field is
|
|
/// present in given field block and its value
|
|
/// was copied into a given parameter-variable.
|
|
template
|
|
<
|
|
class NullValue
|
|
>
|
|
bool
|
|
decimal(
|
|
Decimal& value,
|
|
BlockSize offset,
|
|
const NullValue& null) const
|
|
{
|
|
typedef
|
|
typename
|
|
NullValue::Value
|
|
FieldValue;
|
|
|
|
const FieldValue& fieldValue =
|
|
ordinary<FieldValue>(offset);
|
|
|
|
if (null != fieldValue)
|
|
{
|
|
value = fieldValue;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// Provides access to a value of
|
|
/// an optional field by its offset.
|
|
/// The result is converted into decimal.
|
|
///
|
|
/// Returned result indicates whether field is
|
|
/// present in given field block and its value
|
|
/// was copied into a given parameter-variable.
|
|
///
|
|
/// Field may not be present in earlier versions
|
|
/// of binary message and thus its value may not be
|
|
/// available. For this reason, parameter indicating
|
|
/// version of data assumed is required to access
|
|
/// the field.
|
|
template
|
|
<
|
|
class NullValue
|
|
>
|
|
bool
|
|
decimal(
|
|
Decimal& value,
|
|
BlockSize offset,
|
|
const NullValue& null,
|
|
SchemaVersion since) const
|
|
{
|
|
return (
|
|
since <= block().version()
|
|
&&
|
|
decimal(value, offset, null)
|
|
);
|
|
}
|
|
|
|
/// Provides access to string field by its offset.
|
|
///
|
|
/// Given function serves as specialization
|
|
/// of general case for fields of string type.
|
|
template
|
|
<
|
|
BlockSize Size
|
|
>
|
|
StrRef
|
|
fixedStr(
|
|
BlockSize offset) const
|
|
{
|
|
typedef Char Str[Size];
|
|
|
|
const Str& str =
|
|
ordinary<Str>(offset);
|
|
|
|
return
|
|
StrRef
|
|
(
|
|
str,
|
|
strnlen(str, Size)
|
|
);
|
|
}
|
|
|
|
/// Provides access to an optional
|
|
/// field of string type by its offset.
|
|
///
|
|
/// Given function serves as specialization
|
|
/// of general case for fields of string type.
|
|
template
|
|
<
|
|
BlockSize Size
|
|
>
|
|
StrRef
|
|
fixedStr(
|
|
BlockSize offset,
|
|
SchemaVersion since) const
|
|
{
|
|
return (
|
|
since >=
|
|
block().version()
|
|
|
|
? fixedStr<Size>(offset)
|
|
: StrRef()
|
|
);
|
|
}
|
|
};
|
|
|
|
/// Throws exception on bad repeating group entry.
|
|
ONIXS_CMEMDH_EXPORTED
|
|
void
|
|
throwBadBinaryData(
|
|
const Char* className);
|
|
|
|
/// Encapsulates operations over SBE-encoded
|
|
/// repeating group entry instance.
|
|
template
|
|
<
|
|
class BodySizeType
|
|
>
|
|
class
|
|
BinaryGroupEntry
|
|
: public BinaryFields
|
|
<
|
|
BinaryGroupEntry
|
|
<
|
|
BodySizeType
|
|
>,
|
|
BodySizeType
|
|
>
|
|
{
|
|
const void* body_;
|
|
BodySizeType size_;
|
|
|
|
SchemaVersion version_;
|
|
|
|
public:
|
|
/// Type to present length of binary
|
|
/// data of given repeating group entry.
|
|
typedef
|
|
BodySizeType
|
|
BodySize;
|
|
|
|
/// Initializes instance referring to nothing.
|
|
BinaryGroupEntry()
|
|
: body_(NULL)
|
|
, size_(0)
|
|
, version_(0)
|
|
{
|
|
}
|
|
|
|
/// Initializes instance from memory
|
|
/// block of given SBE-encoded message.
|
|
BinaryGroupEntry(
|
|
const void* body,
|
|
BodySize size,
|
|
SchemaVersion version)
|
|
: body_(body)
|
|
, size_(size)
|
|
, version_(version)
|
|
{
|
|
assert(NULL != body);
|
|
|
|
assert(
|
|
version >=
|
|
SchemaTraits::
|
|
minimalVersion());
|
|
}
|
|
|
|
/// Initializes instance as a copy of the other one.
|
|
BinaryGroupEntry(
|
|
const BinaryGroupEntry& other)
|
|
: body_(
|
|
other.body_)
|
|
, size_(
|
|
other.size_)
|
|
, version_(
|
|
other.version_)
|
|
{
|
|
}
|
|
|
|
/// Indicates whether instance refers to a valid content.
|
|
operator bool() const
|
|
{
|
|
return (NULL != body_);
|
|
}
|
|
|
|
/// Indicates beginning of group entry body.
|
|
const void* body() const
|
|
{
|
|
return body_;
|
|
}
|
|
|
|
/// Indicates end of group entry body.
|
|
BodySize bodySize() const
|
|
{
|
|
return size_;
|
|
}
|
|
|
|
/// Version of message containing
|
|
/// given repeating group instance.
|
|
SchemaVersion version() const
|
|
{
|
|
return version_;
|
|
}
|
|
|
|
/// Re-initializes instance as a copy of the other one.
|
|
BinaryGroupEntry&
|
|
operator =(
|
|
const BinaryGroupEntry& other)
|
|
{
|
|
body_ = other.body_;
|
|
size_ = other.size_;
|
|
|
|
version_ = other.version_;
|
|
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
/// Throws exception on bad repeating group.
|
|
ONIXS_CMEMDH_EXPORTED
|
|
void
|
|
throwBadBinaryGroup();
|
|
|
|
/// Encapsulates operations over SBE-encoded repeating group.
|
|
template
|
|
<
|
|
class EntryType,
|
|
class DimensionType,
|
|
class GroupSizeType
|
|
>
|
|
class BinaryGroup
|
|
{
|
|
public:
|
|
/// Aliases type of repeating group entry.
|
|
typedef EntryType Entry;
|
|
|
|
/// Aliases repeating group dimension type.
|
|
typedef DimensionType Dimension;
|
|
|
|
/// Length of group data.
|
|
typedef GroupSizeType BinarySize;
|
|
|
|
/// Length of group entry data.
|
|
typedef
|
|
typename
|
|
DimensionType::BlockLength
|
|
EntrySize;
|
|
|
|
|
|
/// Size of group (number of entries).
|
|
typedef
|
|
typename
|
|
Dimension::NumInGroup
|
|
Size;
|
|
|
|
/// Provides iterating facilities
|
|
/// over SBE-encoded group entries.
|
|
class Iterator
|
|
{
|
|
const void* entry_;
|
|
EntrySize size_;
|
|
|
|
SchemaVersion version_;
|
|
|
|
public:
|
|
/// Aliases type of object referenced by iterator.
|
|
typedef EntryType Entry;
|
|
|
|
/// Aliases entry for STL conformance.
|
|
typedef const Entry value_type;
|
|
|
|
/// Aliases pointer to entry for STL conformance.
|
|
typedef const Entry* pointer;
|
|
|
|
/// Aliases entry reference for STL conformance.
|
|
typedef const Entry& reference;
|
|
|
|
/// Iterator difference type.
|
|
typedef ptrdiff_t difference_type;
|
|
|
|
/// Identifies iterator category.
|
|
typedef
|
|
std::random_access_iterator_tag
|
|
iterator_category;
|
|
|
|
/// Initializes instance referring to nothing.
|
|
Iterator()
|
|
: entry_(NULL)
|
|
, size_(0)
|
|
, version_(0)
|
|
{
|
|
}
|
|
|
|
/// Initializes instance for given repeating group.
|
|
Iterator(
|
|
const void* entry,
|
|
EntrySize size,
|
|
SchemaVersion version)
|
|
: entry_(entry)
|
|
, size_(size)
|
|
, version_(version)
|
|
{
|
|
}
|
|
|
|
/// Initializes instance as copy of the other one.
|
|
Iterator(
|
|
const Iterator& other)
|
|
: entry_(
|
|
other.entry_)
|
|
, size_(
|
|
other.size_)
|
|
, version_(
|
|
other.version_)
|
|
{
|
|
}
|
|
|
|
/// Repeating group entry referenced by the instance.
|
|
const Entry get() const
|
|
{
|
|
assert(NULL != entry_);
|
|
|
|
return
|
|
Entry(
|
|
entry_,
|
|
size_,
|
|
version_);
|
|
}
|
|
|
|
/// Repeating group entry referenced by the instance.
|
|
const Entry operator *() const
|
|
{
|
|
return get();
|
|
}
|
|
|
|
/// Compares given iterator with the other instance.
|
|
bool
|
|
operator ==(
|
|
const Iterator& other) const
|
|
{
|
|
return entry_ == other.entry_;
|
|
}
|
|
|
|
/// Compares given iterator with the other instance.
|
|
bool
|
|
operator !=(
|
|
const Iterator& other) const
|
|
{
|
|
return entry_ != other.entry_;
|
|
}
|
|
|
|
/// Established order between two iterators.
|
|
bool
|
|
operator <(
|
|
const Iterator& other) const
|
|
{
|
|
return entry_ < other.entry_;
|
|
}
|
|
|
|
/// Established order between two iterators.
|
|
bool
|
|
operator >(
|
|
const Iterator& other) const
|
|
{
|
|
return entry_ > other.entry_;
|
|
}
|
|
|
|
/// Advances instance to the next repeating group entry.
|
|
Iterator&
|
|
operator ++()
|
|
{
|
|
entry_ =
|
|
advanceByBytes(
|
|
entry_, size_);
|
|
|
|
return *this;
|
|
}
|
|
|
|
/// Advances instance to the next repeating group entry.
|
|
Iterator&
|
|
operator --()
|
|
{
|
|
entry_ =
|
|
advanceBackByBytes(
|
|
entry_,
|
|
size_);
|
|
|
|
return *this;
|
|
}
|
|
|
|
/// Advances instance by given number of entries.
|
|
Iterator
|
|
operator +(
|
|
difference_type distance) const
|
|
{
|
|
return
|
|
Iterator(
|
|
advanceByBytes(
|
|
entry_,
|
|
distance * size_),
|
|
size_,
|
|
version_);
|
|
}
|
|
|
|
/// Advances instance by given number of entries.
|
|
Iterator
|
|
operator -(
|
|
difference_type distance) const
|
|
{
|
|
return
|
|
Iterator(
|
|
advanceBackByBytes(
|
|
entry_,
|
|
distance * size_),
|
|
size_,
|
|
version_);
|
|
}
|
|
|
|
/// Re-initializes instance as copy of the other one.
|
|
Iterator&
|
|
operator =(
|
|
const Iterator& other)
|
|
{
|
|
entry_ = other.entry_;
|
|
size_ = other.size_;
|
|
|
|
version_ = other.version_;
|
|
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
/// Initializes blank instance referencing to nothing.
|
|
BinaryGroup()
|
|
: entries_(NULL)
|
|
, entrySize_(0)
|
|
, entryCount_(0)
|
|
, version_(0)
|
|
, size_(0)
|
|
{
|
|
}
|
|
|
|
/// Initializes instance referencing
|
|
/// to a valid group of a given message.
|
|
BinaryGroup(
|
|
const void* data,
|
|
BinarySize size,
|
|
SchemaVersion version)
|
|
: entries_(
|
|
advanceByBytes(
|
|
data,
|
|
Dimension::Size))
|
|
, entrySize_(0)
|
|
, entryCount_(0)
|
|
, version_(version)
|
|
, size_(Dimension::Size)
|
|
{
|
|
if (size < size_)
|
|
throwBadBinaryGroup();
|
|
|
|
const
|
|
Dimension*
|
|
group =
|
|
static_cast
|
|
<const Dimension*>
|
|
(data);
|
|
|
|
entrySize_ =
|
|
group->blockLength();
|
|
|
|
entryCount_ =
|
|
group->numInGroup();
|
|
|
|
size_ +=
|
|
(
|
|
static_cast
|
|
<BinarySize>
|
|
(entrySize_) *
|
|
static_cast
|
|
<BinarySize>
|
|
(entryCount_)
|
|
);
|
|
|
|
if (size < size_)
|
|
throwBadBinaryGroup();
|
|
}
|
|
|
|
/// Initializes instance as a copy of the other one.
|
|
BinaryGroup(
|
|
const BinaryGroup& other)
|
|
: entries_(
|
|
other.entries_)
|
|
, entrySize_(
|
|
other.entrySize_)
|
|
, entryCount_(
|
|
other.entryCount_)
|
|
, version_(
|
|
other.version_)
|
|
, size_(
|
|
other.size_)
|
|
{
|
|
}
|
|
|
|
/// Indicates whether given instance
|
|
/// refers to a valid repeating group.
|
|
operator bool() const
|
|
{
|
|
return (NULL != entries_);
|
|
}
|
|
|
|
/// Indicates whether a repeating
|
|
/// group being referenced is empty.
|
|
bool empty() const
|
|
{
|
|
return 0 == size();
|
|
}
|
|
|
|
/// Returns number of entries in a
|
|
/// repeating group being referenced.
|
|
Size size() const
|
|
{
|
|
return entryCount_;
|
|
}
|
|
|
|
/// Returns iterator pointing to the first repeating group entry.
|
|
Iterator begin() const
|
|
{
|
|
return
|
|
Iterator(
|
|
entries_,
|
|
entrySize_,
|
|
version_);
|
|
}
|
|
|
|
/// Returns iterator pointing to the entry behind the end of the group.
|
|
Iterator end() const
|
|
{
|
|
return
|
|
Iterator(
|
|
advanceByBytes(
|
|
binary(),
|
|
binarySize()),
|
|
entrySize_,
|
|
version_);
|
|
}
|
|
|
|
/// Provides access to a repeating group entry by index.
|
|
/// Index validness is not checked due to performance considerations.
|
|
Entry operator [](Size index) const
|
|
{
|
|
assert(index < size());
|
|
|
|
return
|
|
Entry(
|
|
advanceByBytes(
|
|
entries(),
|
|
index * entrySize_),
|
|
entrySize_,
|
|
version_);
|
|
}
|
|
|
|
/// SBE-encoded data representing repeating group.
|
|
const void* binary() const
|
|
{
|
|
return
|
|
entries_
|
|
? advanceBackByBytes(
|
|
entries_, Dimension::Size)
|
|
: NULL;
|
|
}
|
|
|
|
/// Size of SBE-encoded data representing repeating group.
|
|
BinarySize binarySize() const
|
|
{
|
|
return size_;
|
|
}
|
|
|
|
/// Location of repeating group entries.
|
|
const void* entries() const
|
|
{
|
|
return entries_;
|
|
}
|
|
|
|
/// Size in bytes of single repeating group entry.
|
|
EntrySize entrySize() const
|
|
{
|
|
return entrySize_;
|
|
}
|
|
|
|
/// Re-initializes instance as copy of the other one.
|
|
BinaryGroup&
|
|
operator =(
|
|
const BinaryGroup& other)
|
|
{
|
|
entries_ = other.entries_;
|
|
|
|
entrySize_ = other.entrySize_;
|
|
entryCount_ = other.entryCount_;
|
|
|
|
version_ = other.version_;
|
|
size_ = other.size_;
|
|
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
const void* entries_;
|
|
|
|
EntrySize entrySize_;
|
|
Size entryCount_;
|
|
|
|
SchemaVersion version_;
|
|
BinarySize size_;
|
|
};
|
|
|
|
/// Encapsulates services for manipulating SBE-encoded
|
|
/// groups stored sequentially in SBE-encoded message.
|
|
template
|
|
<
|
|
class BinarySize
|
|
>
|
|
class BinaryGroupList
|
|
{
|
|
const void* binary_;
|
|
BinarySize size_;
|
|
SchemaVersion version_;
|
|
|
|
public:
|
|
/// Initializes empty list.
|
|
BinaryGroupList()
|
|
: binary_(NULL)
|
|
, size_(0)
|
|
, version_(0)
|
|
{
|
|
}
|
|
|
|
/// Initializes list over memory block,
|
|
/// where given message is stored.
|
|
BinaryGroupList(
|
|
const void* binary,
|
|
BinarySize size,
|
|
SchemaVersion version)
|
|
: binary_(binary)
|
|
, size_(size)
|
|
, version_(version)
|
|
{
|
|
}
|
|
|
|
/// Initializes as copy of other list.
|
|
BinaryGroupList(
|
|
const BinaryGroupList& other)
|
|
: binary_(
|
|
other.binary_)
|
|
, size_(
|
|
other.size_)
|
|
, version_(
|
|
other.version_)
|
|
{
|
|
}
|
|
|
|
/// Indicates whether group list is empty.
|
|
bool empty() const
|
|
{
|
|
return (0 == size_);
|
|
}
|
|
|
|
/// Provides access to the head group of the list.
|
|
template
|
|
<
|
|
class Group
|
|
>
|
|
Group head() const
|
|
{
|
|
return
|
|
Group(
|
|
binary_,
|
|
size_,
|
|
version_);
|
|
}
|
|
|
|
/// Returns list of groups following the head.
|
|
template
|
|
<
|
|
class Group
|
|
>
|
|
BinaryGroupList tail() const
|
|
{
|
|
const
|
|
BinarySize
|
|
headSize =
|
|
head<Group>().
|
|
binarySize();
|
|
|
|
assert(headSize <= size_);
|
|
|
|
return
|
|
BinaryGroupList(
|
|
advanceByBytes(
|
|
binary_, headSize),
|
|
size_ - headSize,
|
|
version_);
|
|
}
|
|
|
|
/// SBE-encoded content referenced by given list.
|
|
const void* binary() const
|
|
{
|
|
return binary_;
|
|
}
|
|
|
|
/// Size of SBE-encoded content referenced by the list.
|
|
BinarySize binarySize() const
|
|
{
|
|
return size_;
|
|
}
|
|
|
|
/// Re-initializes instance as copy of the other one.
|
|
BinaryGroupList&
|
|
operator =(
|
|
const BinaryGroupList& other)
|
|
{
|
|
binary_ = other.binary_;
|
|
size_ = other.size_;
|
|
|
|
version_ = other.version_;
|
|
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
/// Raises exception on bad binary message.
|
|
inline
|
|
void
|
|
throwBadBinaryMessage()
|
|
{
|
|
throw std::runtime_error(
|
|
"Cannot construct message instance. Memory "
|
|
"block is too small to access SBE message header. ");
|
|
}
|
|
|
|
/// Raises exception on bad message version.
|
|
ONIXS_CMEMDH_EXPORTED
|
|
void
|
|
throwBadMessageVersion(
|
|
SchemaVersion messageVersion);
|
|
|
|
/// Aliases message type (template) identification.
|
|
typedef
|
|
MessageHeader::TemplateId
|
|
MessageTemplateId;
|
|
|
|
/// Aliases message length type.
|
|
typedef UInt16 MessageSize;
|
|
|
|
/// Encapsulates services for manipulating SBE-encoded messages.
|
|
ONIXS_CMEMDH_LTWT_CLASS
|
|
BinaryMessage
|
|
: public BinaryFields
|
|
<
|
|
BinaryMessage,
|
|
MessageSize
|
|
>
|
|
{
|
|
const MessageHeader* header_;
|
|
MessageSize size_;
|
|
|
|
protected:
|
|
/// Binary group list instantiation.
|
|
typedef
|
|
BinaryGroupList<MessageSize>
|
|
GroupList;
|
|
|
|
/// Returns list of repeating groups
|
|
/// of a message being referenced.
|
|
GroupList groups() const
|
|
{
|
|
assert(NULL != header_);
|
|
|
|
const void*
|
|
const list =
|
|
advanceByBytes(
|
|
body(), bodySize());
|
|
|
|
const
|
|
MessageSize
|
|
listSize =
|
|
size_ -
|
|
MessageHeader::Size -
|
|
header_->blockLength();
|
|
|
|
return
|
|
GroupList(
|
|
list,
|
|
listSize,
|
|
header_->version());
|
|
}
|
|
|
|
public:
|
|
/// Length of message binary data.
|
|
typedef MessageSize BinarySize;
|
|
|
|
/// Length of message body without repeating groups.
|
|
typedef
|
|
MessageHeader::BlockLength
|
|
BodySize;
|
|
|
|
/// Initializes blank instance referencing to nothing.
|
|
BinaryMessage()
|
|
: header_(NULL)
|
|
, size_(0)
|
|
{
|
|
}
|
|
|
|
/// Initializes instance over given memory block.
|
|
BinaryMessage(
|
|
const void* data,
|
|
MessageSize size)
|
|
: header_(
|
|
static_cast
|
|
<const MessageHeader*>
|
|
(data))
|
|
, size_(size)
|
|
{
|
|
assert(NULL != data);
|
|
|
|
if (size <
|
|
MessageHeader::Size
|
|
||
|
|
size <
|
|
(MessageHeader::Size +
|
|
header_->blockLength()))
|
|
{
|
|
throwBadBinaryMessage();
|
|
}
|
|
|
|
const
|
|
SchemaVersion
|
|
version = this->version();
|
|
|
|
if (version <
|
|
SchemaTraits::minimalVersion())
|
|
{
|
|
throwBadMessageVersion(version);
|
|
}
|
|
}
|
|
|
|
/// Initializes instance as copy of the other one.
|
|
BinaryMessage(
|
|
const BinaryMessage& other)
|
|
: header_(other.header_)
|
|
, size_(other.size_)
|
|
{
|
|
}
|
|
|
|
/// Indicates whether instance refers to a valid message.
|
|
operator bool() const
|
|
{
|
|
return (NULL != header_);
|
|
}
|
|
|
|
/// Template identifier of message being referenced.
|
|
MessageTemplateId templateId() const
|
|
{
|
|
assert(NULL != header_);
|
|
|
|
return header_->templateId();
|
|
}
|
|
|
|
/// Version of message being referenced.
|
|
SchemaVersion version() const
|
|
{
|
|
assert(NULL != header_);
|
|
|
|
return header_->version();
|
|
}
|
|
|
|
/// SBE-encoded message content.
|
|
const void* binary() const
|
|
{
|
|
return header_;
|
|
}
|
|
|
|
/// Size of SBE-encoded message.
|
|
MessageSize binarySize() const
|
|
{
|
|
return size_;
|
|
}
|
|
|
|
/// Indicates beginning of message body.
|
|
const void* body() const
|
|
{
|
|
assert(NULL != header_);
|
|
|
|
return
|
|
advanceByBytes(
|
|
header_,
|
|
MessageHeader::Size);
|
|
}
|
|
|
|
/// Size of message body in bytes.
|
|
BodySize bodySize() const
|
|
{
|
|
assert(NULL != header_);
|
|
|
|
return header_->blockLength();
|
|
}
|
|
|
|
/// Re-initializes instance as a copy of the other one.
|
|
BinaryMessage&
|
|
operator =(
|
|
const BinaryMessage& other)
|
|
{
|
|
header_ = other.header_;
|
|
size_ = other.size_;
|
|
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
ONIXS_CMEMDH_NAMESPACE_END
|