Files

591 lines
18 KiB
C++

/**
* @file include/ActivMiddleware/ActivBase/GenericMessages/MessageStorage.h
*
* @brief Header for MessageStorage class.
*/
#if (!defined ACTIV_BASE_GENERIC_MESSAGES_MESSAGE_STORAGE_H)
#define ACTIV_BASE_GENERIC_MESSAGES_MESSAGE_STORAGE_H
#include "ActivMiddleware/ActivBase/GenericMessages/Formats/Common/FieldDispatcher.h"
#include "ActivMiddleware/ActivBase/GenericMessages/Detail/OptionalFieldsHelper.h"
#include ACTIV_BOOST_INCLUDE(mpl/inherit_linearly.hpp)
#include ACTIV_BOOST_INCLUDE(mpl/inherit.hpp)
#include ACTIV_BOOST_INCLUDE(mpl/transform.hpp)
#include ACTIV_BOOST_INCLUDE(mpl/contains.hpp)
//! Activ namespace.
namespace Activ
{
//! GenericMessages namespace.
namespace GenericMessages
{
namespace Detail
{
// Metafunction to select the Storage type from a Field class.
template<typename FIELD>
class FieldStorageAccessor
{
public:
typedef typename FIELD::Storage type;
};
} // namespace Detail
// ---------------------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------------------------------------------
// Undefined. Specialization exists for each format.
template<typename FORMAT, typename MESSAGE_STORAGE>
class MessageStorageFormat;
// ---------------------------------------------------------------------------------------------------------------------------------
/**
* @brief Container with concrete storage for a message's fields.
*
* MessageStorage includes storage for each field.
*
* @tparam FIELD_LIST is a Boost::mpl sequence of Field classes defining the message.
* @tparam NAME an optional StringLiteral for the name of the message.
*/
template<typename FIELD_LIST, typename NAME>
class MessageStorage : public Boost::mpl::inherit_linearly<typename Boost::mpl::transform<FIELD_LIST,
Detail::FieldStorageAccessor<Boost::mpl::_1> >::type, Boost::mpl::inherit<Boost::mpl::_1, Boost::mpl::_2> >::type
{
typedef GenericMessages::Definition<FIELD_LIST, NAME> Definition;
typedef typename Boost::mpl::inherit_linearly<typename Boost::mpl::transform<FIELD_LIST,
Detail::FieldStorageAccessor<Boost::mpl::_1> >::type, Boost::mpl::inherit<Boost::mpl::_1, Boost::mpl::_2> >::type Base;
public:
//! Default constructor.
MessageStorage() :
m_presentFieldIdBitmap(Definition::highestFieldId + 1, false),
m_defaultedFieldIdBitmap(Definition::highestFieldId + 1, false)
{
}
#if (!defined ACTIV_BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
// Default copy is sufficient.
MessageStorage(const MessageStorage &) = default;
MessageStorage &operator=(const MessageStorage &) = default;
//! Move constructor.
MessageStorage(ACTIV_BOOST_RV_REF(MessageStorage) rhs) :
Base(CxxYZ::move(rhs)),
// Note copies of bitmaps such that the rhs size remains Definition::highestFieldId + 1, hence =default not sufficient.
m_presentFieldIdBitmap(rhs.m_presentFieldIdBitmap),
m_defaultedFieldIdBitmap(rhs.m_defaultedFieldIdBitmap),
m_presentFieldIdList(CxxYZ::move(rhs.m_presentFieldIdList)),
m_unknownFieldIdList(CxxYZ::move(rhs.m_unknownFieldIdList))
{
}
//! Move assignment.
MessageStorage &operator=(MessageStorage &&rhs)
{
if (this != CxxYZ::addressof(rhs))
{
Base::operator=(CxxYZ::move(rhs));
// Note copies of bitmaps such that the rhs size remains Definition::highestFieldId + 1, hence =default not sufficient.
m_presentFieldIdBitmap = rhs.m_presentFieldIdBitmap;
m_defaultedFieldIdBitmap = rhs.m_defaultedFieldIdBitmap;
m_presentFieldIdList = CxxYZ::move(rhs.m_presentFieldIdList);
m_unknownFieldIdList = CxxYZ::move(rhs.m_unknownFieldIdList);
}
return *this;
}
#else
private:
class CopyField
{
public:
CopyField(MessageStorage &lhs, const MessageStorage &rhs) :
m_lhs(lhs),
m_rhs(rhs)
{
}
template<typename FIELD>
void operator()(Identity<FIELD>) const
{
ACTIV_BOOST_STATIC_ASSERT((Boost::mpl::contains<FIELD_LIST, FIELD>::type::value));
typedef typename FIELD::Storage FieldStorage;
FieldStorage &lhsField(static_cast<FieldStorage &>(m_lhs));
const FieldStorage &rhsField(static_cast<const FieldStorage &>(m_rhs));
lhsField = rhsField;
}
private:
MessageStorage & m_lhs;
const MessageStorage & m_rhs;
};
class MoveField
{
public:
MoveField(MessageStorage &lhs, MessageStorage &rhs) :
m_lhs(lhs),
m_rhs(rhs)
{
}
template<typename FIELD>
void operator()(Identity<FIELD>) const
{
ACTIV_BOOST_STATIC_ASSERT((Boost::mpl::contains<FIELD_LIST, FIELD>::type::value));
typedef typename FIELD::Storage FieldStorage;
FieldStorage &lhsField(static_cast<FieldStorage &>(m_lhs));
FieldStorage &rhsField(static_cast<FieldStorage &>(m_rhs));
lhsField = CxxYZ::move(rhsField);
}
private:
MessageStorage &m_lhs;
MessageStorage &m_rhs;
};
public:
//! Copy constructor.
MessageStorage(const MessageStorage &rhs) :
Base(rhs),
m_presentFieldIdBitmap(rhs.m_presentFieldIdBitmap),
m_defaultedFieldIdBitmap(rhs.m_defaultedFieldIdBitmap),
m_presentFieldIdList(rhs.m_presentFieldIdList),
m_unknownFieldIdList(rhs.m_unknownFieldIdList)
{
}
//! Move constructor.
MessageStorage(ACTIV_BOOST_RV_REF(MessageStorage) rhs) :
// Note copies of bitmaps such that the rhs size remains Definition::highestFieldId + 1.
m_presentFieldIdBitmap(rhs.m_presentFieldIdBitmap),
m_defaultedFieldIdBitmap(rhs.m_defaultedFieldIdBitmap),
m_presentFieldIdList(CxxYZ::move(rhs.m_presentFieldIdList)),
m_unknownFieldIdList(CxxYZ::move(rhs.m_unknownFieldIdList))
{
// Note no call to Base's move constructor. MPL has no support for ACTIV_BOOST_MOVE_BASE, so we have to do it ourselves.
// Paying the cost of the default construction of all the bases.
MoveField moveField(*this, rhs);
Boost::mpl::for_each<FIELD_LIST, MakeIdentity<Boost::mpl::_1> >(moveField);
}
// Copy assignment.
MessageStorage &operator=(ACTIV_BOOST_COPY_ASSIGN_REF(MessageStorage) rhs)
{
if (this != CxxYZ::addressof(rhs))
{
// Base::operator=() not available, have to do it ourselves.
CopyField copyField(*this, rhs);
Boost::mpl::for_each<FIELD_LIST, MakeIdentity<Boost::mpl::_1> >(copyField);
m_presentFieldIdBitmap = rhs.m_presentFieldIdBitmap;
m_defaultedFieldIdBitmap = rhs.m_defaultedFieldIdBitmap;
m_presentFieldIdList = rhs.m_presentFieldIdList;
m_unknownFieldIdList = rhs.m_unknownFieldIdList;
}
return *this;
}
// Move assignment.
MessageStorage &operator=(ACTIV_BOOST_RV_REF(MessageStorage) rhs)
{
if (this != CxxYZ::addressof(rhs))
{
// Base::operator=() not available, have to do it ourselves.
MoveField moveField(*this, rhs);
Boost::mpl::for_each<FIELD_LIST, MakeIdentity<Boost::mpl::_1> >(moveField);
// Note copies of bitmaps such that the rhs size remains Definition::highestFieldId + 1.
m_presentFieldIdBitmap = rhs.m_presentFieldIdBitmap;
m_defaultedFieldIdBitmap = rhs.m_defaultedFieldIdBitmap;
m_presentFieldIdList = CxxYZ::move(rhs.m_presentFieldIdList);
m_unknownFieldIdList = CxxYZ::move(rhs.m_unknownFieldIdList);
}
return *this;
}
#endif
/**
* @brief Set a field.
*
* FIELD must be a member of FIELD_LIST.
*
* @param value
*/
template<typename FIELD>
void Set(typename Detail::FieldStorageAccessor<FIELD>::type::StorageParamType value)
{
ACTIV_BOOST_STATIC_ASSERT_MSG((Boost::mpl::contains<FIELD_LIST, FIELD>::type::value),
"Field being accessed must be a member of the message definition");
static_cast<typename Detail::FieldStorageAccessor<FIELD>::type &>(*this).Set(value);
SetFieldPresent(FIELD::id);
}
/**
* @brief Set a field.
*
* FIELD must be a member of FIELD_LIST.
*
* @param value
*/
template<typename FIELD>
typename CxxYZ::enable_if<
CxxYZ::is_reference<typename Detail::FieldStorageAccessor<FIELD>::type::StorageParamType>::value>::type
Set(ACTIV_BOOST_RV_REF(typename Detail::FieldStorageAccessor<FIELD>::type::StorageType) value)
{
// Note not enabled if the field is trivial and can be passed by value to FieldStorage::Set() (will be ambiguous).
ACTIV_BOOST_STATIC_ASSERT_MSG((Boost::mpl::contains<FIELD_LIST, FIELD>::type::value),
"Field being accessed must be a member of the message definition");
static_cast<typename Detail::FieldStorageAccessor<FIELD>::type &>(*this).Set(CxxYZ::move(value));
SetFieldPresent(FIELD::id);
}
/**
* @brief Is a field present in the message?
*
* FIELD must be a member of FIELD_LIST.
*/
template<typename FIELD>
bool IsFieldPresent() const
{
ACTIV_BOOST_STATIC_ASSERT_MSG((Boost::mpl::contains<FIELD_LIST, FIELD>::type::value),
"Field being accessed must be a member of the message definition");
return m_presentFieldIdBitmap[FIELD::id];
}
/**
* @brief Get the list of unknown field id received after deserialization.
*
* @return Const reference to a FieldIdList.
*/
const FieldIdList &GetUnknownFieldIdList() const
{
return m_unknownFieldIdList;
}
/**
* @brief Serialize all the fields that have been Set() in this message to a particular format.
*
* @tparam FORMAT the format to serialize to.
* @tparam T the serializer type (MessageBuilder, rapidjson::writer, etc.).
*
* @param serializer
*
* @return STATUS_CODE_SUCCESS or error status.
*/
template<typename FORMAT, typename T>
StatusCode Serialize(T &serializer) const
{
return MessageStorageFormat<FORMAT, MessageStorage>::Serialize(serializer, *this);
}
/**
* @brief Serialize all the fields that have been Set() in a message to a particular format.
*
* @tparam FORMAT the format to serialize to.
* @tparam T the serializer type (MessageBuilder, rapidjson::writer, etc.).
*
* @param serializer
* @param messageStorage
*
* @return STATUS_CODE_SUCCESS or error status.
*/
template<typename FORMAT, typename T>
static StatusCode Serialize(T &serializer, const MessageStorage &messageStorage)
{
// Note the static version is provided such that generic code can call this function taking MessageStorage
// or a Serialize(messageBuilder, regular-c++-object).
return messageStorage.Serialize<FORMAT>(serializer);
}
/**
* @brief Deserialize a message.
*
* @tparam FORMAT the format the serialized data is in.
* @tparam T the serialized data type (MessageValidator, Json::Value, etc.).
*
* @param messageValidator
*
* @return STATUS_CODE_SUCCESS or error status.
*/
template<typename FORMAT, typename T>
StatusCode Deserialize(T &messageValidator)
{
typedef typename FieldDispatcherSingleton<FORMAT, Definition>::type FieldDispatcherSingleton;
const FieldDispatcherSingleton &fieldDispatcherSingleton(FieldDispatcherSingleton::GetInstance());
ACTIV_RETURN_RESULT_IF_UNLIKELY(STATUS_CODE_SUCCESS, !=,
(MessageStorageFormat<FORMAT, MessageStorage>::Deserialize(messageValidator, *this, fieldDispatcherSingleton)));
if (ACTIV_LIKELY(fieldDispatcherSingleton.AreAllMandatoryFieldsPresent(this->m_presentFieldIdBitmap)))
SetOptionalFieldValues(fieldDispatcherSingleton);
else
return STATUS_CODE_MISSING_FIELDS;
return STATUS_CODE_SUCCESS;
}
/**
* @brief Deserialize a message.
*
* @tparam FORMAT the format the serialized data is in.
* @tparam T the serialized data type (MessageValidator, Json::Value, etc.).
*
* @param messageValidator
* @param messageStorage
*
* @return STATUS_CODE_SUCCESS or error status.
*/
template<typename FORMAT, typename T>
static StatusCode Deserialize(T &messageValidator, MessageStorage &messageStorage)
{
// Note the static version is such that generic code can call this function taking MessageStorage
// or a Deserialize(messageValidator, regular-c++-object).
return messageStorage.Deserialize<FORMAT>(messageValidator);
}
/**
* @brief Serialize all the fields that have been Set() in the message to ACTIV format.
*
* @param messageBuilder
*
* @return STATUS_CODE_SUCCESS or error status.
*/
StatusCode Serialize(MessageBuilder &messageBuilder) const
{
return Serialize<Formats::Activ::Tag>(messageBuilder);
}
/**
* @brief Deserialize a message in ACTIV format.
*
* @param messageValidator
*
* @return STATUS_CODE_SUCCESS or error status.
*/
StatusCode Deserialize(MessageValidator &messageValidator)
{
return Deserialize<Formats::Activ::Tag>(messageValidator);
}
/**
* @brief Get a field's value.
*
* FIELD must be a member of FIELD_LIST.
*
* @return Const reference to the field's value (for non-built in types), or the field's value (for built-in types).
*
* @throw StatusCodeException if the field is not set in the message.
*/
template<typename FIELD>
typename FIELD::Storage::StorageParamType Get() const
{
ACTIV_BOOST_STATIC_ASSERT_MSG((Boost::mpl::contains<FIELD_LIST, FIELD>::type::value),
"Field being accessed must be a member of the message definition");
if (ACTIV_LIKELY(this->m_presentFieldIdBitmap[FIELD::id]))
return static_cast<const typename FIELD::Storage &>(*this).Get();
else
ACTIV_THROW(StatusCodeException, STATUS_CODE_UNDEFINED_FIELD);
}
/**
* @brief Get a field's value.
*
* @return Reference to the field's value.
*
* @throw StatusCodeException if the field is not set in the message.
*/
template<typename FIELD>
typename FIELD::Storage::StorageType &Get()
{
ACTIV_BOOST_STATIC_ASSERT_MSG((Boost::mpl::contains<FIELD_LIST, FIELD>::type::value),
"Field being accessed must be a member of the message definition");
if (ACTIV_LIKELY(this->m_presentFieldIdBitmap[FIELD::id]))
return static_cast<typename FIELD::Storage &>(*this).Get();
else
ACTIV_THROW(StatusCodeException, STATUS_CODE_UNDEFINED_FIELD);
}
/**
* @brief Is a field defaulted?
*
* FIELD must be a member of FIELD_LIST.
*
* @return true if the (optional) field was not present in a serialized message and has been set to its default value.
*/
template<typename FIELD>
bool IsFieldDefaulted() const
{
ACTIV_BOOST_STATIC_ASSERT_MSG((Boost::mpl::contains<FIELD_LIST, FIELD>::type::value),
"Field being accessed must be a member of the message definition");
return m_defaultedFieldIdBitmap[FIELD::id];
}
/**
* @brief Clear down the message storage.
*
* Note field values are not altered; the message is simply marked as having no fields present.
*/
void Reset()
{
m_presentFieldIdBitmap.reset();
m_defaultedFieldIdBitmap.reset();
m_presentFieldIdList.clear();
m_unknownFieldIdList.clear();
}
//! Equality operator. Defaulted fields do not take part in the comparison.
bool operator==(const MessageStorage &rhs) const
{
return CompareFields<std::equal_to>(rhs);
}
//! Inequality operator. Defaulted fields do not take part in the comparison.
bool operator!=(const MessageStorage &rhs) const
{
return !operator==(rhs);
}
private:
template<template<typename> class T>
class FieldComparator
{
public:
FieldComparator(const MessageStorage &lhs, const MessageStorage &rhs) :
m_lhs(lhs),
m_rhs(rhs)
{
// Passing lhs and rhs to operator() and bind()ing them at the call site blows up VS2015 with alarming regularity,
// hence passing to the constructor.
}
template<typename FIELD>
void operator()(Identity<FIELD>) const
{
ACTIV_BOOST_STATIC_ASSERT((Boost::mpl::contains<FIELD_LIST, FIELD>::type::value));
if (m_lhs.m_presentFieldIdBitmap[FIELD::id] && m_rhs.m_presentFieldIdBitmap[FIELD::id] &&
!m_lhs.IsFieldDefaulted<FIELD>() && !m_rhs.IsFieldDefaulted<FIELD>())
{
typedef typename FIELD::Storage FieldStorage;
const FieldStorage &lhsField(static_cast<const FieldStorage &>(m_lhs));
const FieldStorage &rhsField(static_cast<const FieldStorage &>(m_rhs));
if (!T<FieldStorage>()(lhsField, rhsField))
throw false;
}
}
private:
const MessageStorage &m_lhs;
const MessageStorage &m_rhs;
};
template<template<typename> class T>
bool CompareFields(const MessageStorage &rhs) const
{
try
{
FieldComparator<T> fieldComparator(*this, rhs);
Boost::mpl::for_each<FIELD_LIST, MakeIdentity<Boost::mpl::_1> >(fieldComparator);
}
ACTIV_CATCH_ALL()
{
return false;
}
return true;
}
template<typename T>
class SetOptionalField
{
public:
SetOptionalField(MessageStorage &messageStorage, const T &fieldDispatcherSingleton) :
m_messageStorage(messageStorage),
m_fieldDispatcherSingleton(fieldDispatcherSingleton)
{
}
void operator()(const FieldId fieldId) const
{
const typename T::IFieldDispatcher * const pIFieldDispatcher(m_fieldDispatcherSingleton.GetFieldDispatcher(fieldId));
if (ACTIV_LIKELY(ACTIV_NULLPTR != pIFieldDispatcher))
{
pIFieldDispatcher->SetDefault(m_messageStorage);
m_messageStorage.SetFieldPresent(fieldId);
m_messageStorage.m_defaultedFieldIdBitmap[fieldId] = true;
}
else
{
assert(false);
}
}
private:
MessageStorage &m_messageStorage;
const T & m_fieldDispatcherSingleton;
};
//! Mark a field as being present in the message.
void SetFieldPresent(const FieldId id)
{
if (!m_presentFieldIdBitmap[id])
{
m_presentFieldIdList.push_back(id);
m_presentFieldIdBitmap[id] = true;
}
}
//! Set the values for any optional fields not present after a Deserialize(). Or SetOptional takes format.
template<typename T>
void SetOptionalFieldValues(const T &fieldDispatcherSingleton)
{
SetOptionalField<T> setOptionalField(*this, fieldDispatcherSingleton);
Detail::ForNotPresentOptionalFields<typename Definition::DefaultedOptionalFieldList>(this->m_presentFieldIdBitmap,
setOptionalField);
}
FieldIdBitmap m_presentFieldIdBitmap;
FieldIdBitmap m_defaultedFieldIdBitmap;
FieldIdList m_presentFieldIdList;
FieldIdList m_unknownFieldIdList;
template<typename FORMAT, typename MESSAGE_STORAGE>
friend class MessageStorageFormat;
ACTIV_BOOST_COPYABLE_AND_MOVABLE(MessageStorage)
};
} // namespace GenericMessages
} // namespace Activ
#endif // (!defined ACTIV_BASE_GENERIC_MESSAGES_MESSAGE_STORAGE_H)