331 lines
9.9 KiB
C++
331 lines
9.9 KiB
C++
/**
|
|
* @file include/ActivMiddleware/Misc/SerializableBuffer.h
|
|
*
|
|
* @brief Serializable buffer.
|
|
*/
|
|
|
|
#if (!defined ACTIV_MISC_SERIALIZABLE_BUFFER_H)
|
|
#define ACTIV_MISC_SERIALIZABLE_BUFFER_H
|
|
|
|
#include "ActivMiddleware/Misc/MemoryHelper.h"
|
|
|
|
#include ACTIV_BOOST_INCLUDE(integer_traits.hpp)
|
|
#include ACTIV_BOOST_INCLUDE(move/move.hpp)
|
|
|
|
//! Activ namespace.
|
|
namespace Activ
|
|
{
|
|
|
|
/**
|
|
* @brief Serializable buffer template.
|
|
*
|
|
* @param LENGTH_TYPE type of length to serialize.
|
|
* @param MIN_LENGTH min length of serializable buffer.
|
|
* @param MAX_LENGTH max length of serializable buffer.
|
|
*/
|
|
template <typename LENGTH_TYPE, LENGTH_TYPE MIN_LENGTH = 0, LENGTH_TYPE MAX_LENGTH = Boost::integer_traits<LENGTH_TYPE>::const_max>
|
|
class SerializableBuffer
|
|
{
|
|
public:
|
|
typedef LENGTH_TYPE Length;
|
|
|
|
//! Default constructor.
|
|
SerializableBuffer();
|
|
|
|
//! Move constructor.
|
|
SerializableBuffer(ACTIV_BOOST_RV_REF(SerializableBuffer) rhs);
|
|
|
|
//! Destructor.
|
|
~SerializableBuffer();
|
|
|
|
//! Move assignment operator.
|
|
SerializableBuffer &operator=(ACTIV_BOOST_RV_REF(SerializableBuffer) rhs);
|
|
|
|
/**
|
|
* @brief Set data pointer and length.
|
|
*
|
|
* @param pData pointer to data.
|
|
* @param dataLength length of data pointed to by @a pData.
|
|
* @param shouldCopy if true then data is copied into the object, otherwise just sets the pointer value and length.
|
|
*
|
|
* @retval STATUS_CODE_SUCCESS.
|
|
* @retval ...
|
|
*/
|
|
StatusCode Set(const void *pData, const size_t dataLength, const bool shouldCopy);
|
|
|
|
/**
|
|
* @brief Get pointer to data.
|
|
*
|
|
* @return Pointer to data.
|
|
*/
|
|
const void *GetData() const;
|
|
|
|
/**
|
|
* @brief Get length of data.
|
|
*
|
|
* @return Length of data.
|
|
*/
|
|
size_t GetDataLength() const;
|
|
|
|
/**
|
|
* @brief Serialize.
|
|
*
|
|
* @param messageBuilder
|
|
* @param pData data to serialize.
|
|
* @param dataLength length of data to serialize.
|
|
*
|
|
* @retval STATUS_CODE_SUCCESS.
|
|
* @retval ...
|
|
*/
|
|
static StatusCode Serialize(MessageBuilder &messageBuilder, const void * const pData, const size_t dataLength);
|
|
|
|
/**
|
|
* @brief Serialize.
|
|
*
|
|
* @param messageBuilder
|
|
*
|
|
* @retval STATUS_CODE_SUCCESS.
|
|
* @retval ...
|
|
*/
|
|
StatusCode Serialize(MessageBuilder &messageBuilder) const;
|
|
|
|
/**
|
|
* @brief Deserialize.
|
|
*
|
|
* @tparam COPY_DATA whether to copy data to an internally managed buffer or just store a pointer.
|
|
*
|
|
* @param messageValidator
|
|
*
|
|
* @retval STATUS_CODE_SUCCESS.
|
|
* @retval ...
|
|
*/
|
|
template<bool COPY_DATA>
|
|
StatusCode Deserialize(MessageValidator &messageValidator);
|
|
|
|
private:
|
|
ACTIV_BOOST_MOVABLE_BUT_NOT_COPYABLE(SerializableBuffer)
|
|
|
|
/**
|
|
* @brief Adjust internal buffer size.
|
|
*
|
|
* @param requiredLength size of buffer required.
|
|
*
|
|
* @retval STATUS_CODE_SUCCESS.
|
|
* @retval STATUS_CODE_HEAP_EMPTY.
|
|
*/
|
|
StatusCode AdjustBufferSize(const size_t requiredLength);
|
|
|
|
const void *m_pData;
|
|
size_t m_dataLength;
|
|
|
|
void * m_pBuffer;
|
|
size_t m_bufferLength;
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
template <typename LENGTH_TYPE, LENGTH_TYPE MIN_LENGTH, LENGTH_TYPE MAX_LENGTH>
|
|
inline SerializableBuffer<LENGTH_TYPE, MIN_LENGTH, MAX_LENGTH>::SerializableBuffer() :
|
|
m_pData(ACTIV_NULLPTR),
|
|
m_dataLength(0),
|
|
m_pBuffer(ACTIV_NULLPTR),
|
|
m_bufferLength(0)
|
|
{
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
template <typename LENGTH_TYPE, LENGTH_TYPE MIN_LENGTH, LENGTH_TYPE MAX_LENGTH>
|
|
inline SerializableBuffer<LENGTH_TYPE, MIN_LENGTH, MAX_LENGTH>::SerializableBuffer(ACTIV_BOOST_RV_REF(SerializableBuffer) rhs) :
|
|
m_pData(rhs.m_pData),
|
|
m_dataLength(rhs.m_dataLength),
|
|
m_pBuffer(rhs.m_pBuffer),
|
|
m_bufferLength(rhs.m_bufferLength)
|
|
{
|
|
rhs.m_pData = ACTIV_NULLPTR;
|
|
rhs.m_dataLength = 0;
|
|
rhs.m_pBuffer = ACTIV_NULLPTR;
|
|
rhs.m_bufferLength = 0;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
template <typename LENGTH_TYPE, LENGTH_TYPE MIN_LENGTH, LENGTH_TYPE MAX_LENGTH>
|
|
inline SerializableBuffer<LENGTH_TYPE, MIN_LENGTH, MAX_LENGTH>::~SerializableBuffer()
|
|
{
|
|
if (ACTIV_NULLPTR != m_pBuffer)
|
|
std::free(m_pBuffer);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
template <typename LENGTH_TYPE, LENGTH_TYPE MIN_LENGTH, LENGTH_TYPE MAX_LENGTH>
|
|
inline SerializableBuffer<LENGTH_TYPE, MIN_LENGTH, MAX_LENGTH> &SerializableBuffer<LENGTH_TYPE, MIN_LENGTH, MAX_LENGTH>::operator=(
|
|
ACTIV_BOOST_RV_REF(SerializableBuffer) rhs)
|
|
{
|
|
if (this != &rhs)
|
|
{
|
|
if (ACTIV_NULLPTR != m_pBuffer)
|
|
std::free(m_pBuffer);
|
|
|
|
m_pData = rhs.m_pData;
|
|
m_dataLength = rhs.m_dataLength;
|
|
m_pBuffer = rhs.m_pBuffer;
|
|
m_bufferLength = rhs.m_bufferLength;
|
|
|
|
rhs.m_pData = ACTIV_NULLPTR;
|
|
rhs.m_dataLength = 0;
|
|
rhs.m_pBuffer = ACTIV_NULLPTR;
|
|
rhs.m_bufferLength = 0;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
template <typename LENGTH_TYPE, LENGTH_TYPE MIN_LENGTH, LENGTH_TYPE MAX_LENGTH>
|
|
inline StatusCode SerializableBuffer<LENGTH_TYPE, MIN_LENGTH, MAX_LENGTH>::Set(const void *pData, const size_t dataLength,
|
|
const bool shouldCopy)
|
|
{
|
|
m_pData = ACTIV_NULLPTR;
|
|
m_dataLength = 0;
|
|
|
|
if ((ACTIV_NULLPTR == pData) || (0 == dataLength))
|
|
return STATUS_CODE_SUCCESS;
|
|
|
|
if (shouldCopy)
|
|
{
|
|
ACTIV_RETURN_RESULT_IF_UNLIKELY(STATUS_CODE_SUCCESS, !=, AdjustBufferSize(dataLength));
|
|
MemoryCopy(m_pBuffer, pData, dataLength);
|
|
|
|
m_pData = m_pBuffer;
|
|
m_dataLength = dataLength;
|
|
}
|
|
else
|
|
{
|
|
m_pData = pData;
|
|
m_dataLength = dataLength;
|
|
}
|
|
|
|
return STATUS_CODE_SUCCESS;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
template <typename LENGTH_TYPE, LENGTH_TYPE MIN_LENGTH, LENGTH_TYPE MAX_LENGTH>
|
|
inline const void *SerializableBuffer<LENGTH_TYPE, MIN_LENGTH, MAX_LENGTH>::GetData() const
|
|
{
|
|
return m_pData;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
template <typename LENGTH_TYPE, LENGTH_TYPE MIN_LENGTH, LENGTH_TYPE MAX_LENGTH>
|
|
inline size_t SerializableBuffer<LENGTH_TYPE, MIN_LENGTH, MAX_LENGTH>::GetDataLength() const
|
|
{
|
|
return m_dataLength;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
template <typename LENGTH_TYPE, LENGTH_TYPE MIN_LENGTH, LENGTH_TYPE MAX_LENGTH>
|
|
inline StatusCode SerializableBuffer<LENGTH_TYPE, MIN_LENGTH, MAX_LENGTH>::Serialize(MessageBuilder &messageBuilder,
|
|
const void * const pData, const size_t dataLength)
|
|
{
|
|
ACTIV_BOOST_STATIC_ASSERT(Boost::is_unsigned<LENGTH_TYPE>::value);
|
|
|
|
typedef typename Boost::mpl::if_c<
|
|
(sizeof(LENGTH_TYPE) > sizeof(size_t)),
|
|
LENGTH_TYPE,
|
|
size_t
|
|
>::type MaxLength;
|
|
|
|
if (Less<MaxLength, MIN_LENGTH>()(dataLength) || (Greater<MaxLength, MAX_LENGTH>()(dataLength)))
|
|
return STATUS_CODE_INVALID_LENGTH;
|
|
|
|
ACTIV_RETURN_RESULT_IF_UNLIKELY(STATUS_CODE_SUCCESS, !=,
|
|
messageBuilder.Append<MessageBuilder::ENDIAN_LITTLE>(static_cast<LENGTH_TYPE>(dataLength)));
|
|
ACTIV_RETURN_RESULT_IF_UNLIKELY(STATUS_CODE_SUCCESS, !=, messageBuilder.AppendBuffer(pData, dataLength));
|
|
|
|
return STATUS_CODE_SUCCESS;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
template <typename LENGTH_TYPE, LENGTH_TYPE MIN_LENGTH, LENGTH_TYPE MAX_LENGTH>
|
|
inline StatusCode SerializableBuffer<LENGTH_TYPE, MIN_LENGTH, MAX_LENGTH>::Serialize(MessageBuilder &messageBuilder) const
|
|
{
|
|
return Serialize(messageBuilder, m_pData, m_dataLength);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
template <typename LENGTH_TYPE, LENGTH_TYPE MIN_LENGTH, LENGTH_TYPE MAX_LENGTH>
|
|
template <bool COPY_DATA>
|
|
inline StatusCode SerializableBuffer<LENGTH_TYPE, MIN_LENGTH, MAX_LENGTH>::Deserialize(MessageValidator &messageValidator)
|
|
{
|
|
m_pData = ACTIV_NULLPTR;
|
|
m_dataLength = 0;
|
|
|
|
LENGTH_TYPE dataLength;
|
|
|
|
ACTIV_RETURN_RESULT_IF_UNLIKELY(STATUS_CODE_SUCCESS, !=,
|
|
(messageValidator.ValidateBinaryIntegralRange<sizeof(LENGTH_TYPE), MessageValidator::ENDIAN_LITTLE>(MIN_LENGTH, MAX_LENGTH,
|
|
dataLength)));
|
|
|
|
if (dataLength > 0)
|
|
{
|
|
if (COPY_DATA)
|
|
{
|
|
ACTIV_RETURN_RESULT_IF_UNLIKELY(STATUS_CODE_SUCCESS, !=, AdjustBufferSize(static_cast<size_t>(dataLength)));
|
|
ACTIV_RETURN_RESULT_IF_UNLIKELY(STATUS_CODE_SUCCESS, !=,
|
|
messageValidator.ValidateBytesCopy(static_cast<size_t>(dataLength), m_pBuffer));
|
|
|
|
m_pData = m_pBuffer;
|
|
}
|
|
else
|
|
{
|
|
const void *pData = reinterpret_cast<const byte_t *>(messageValidator.GetMessage()) + messageValidator.GetOffset();
|
|
ACTIV_RETURN_RESULT_IF_UNLIKELY(STATUS_CODE_SUCCESS, !=, messageValidator.ValidateBytes(dataLength));
|
|
|
|
m_pData = pData;
|
|
}
|
|
|
|
m_dataLength = static_cast<size_t>(dataLength);
|
|
}
|
|
|
|
return STATUS_CODE_SUCCESS;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
template <typename LENGTH_TYPE, LENGTH_TYPE MIN_LENGTH, LENGTH_TYPE MAX_LENGTH>
|
|
StatusCode SerializableBuffer<LENGTH_TYPE, MIN_LENGTH, MAX_LENGTH>::AdjustBufferSize(const size_t requiredLength)
|
|
{
|
|
if (requiredLength > m_bufferLength)
|
|
{
|
|
// Adjust buffer (greater of 1.5 * existing size or the requested size).
|
|
size_t newBufferLength = std::max<>(requiredLength, m_bufferLength + (m_bufferLength / 2));
|
|
|
|
// And round to 4 bytes.
|
|
newBufferLength += 3;
|
|
newBufferLength &= ~3;
|
|
|
|
void * const pNewBuffer = std::realloc(m_pBuffer, newBufferLength);
|
|
|
|
// NB in this case the original buffer is left intact.
|
|
if (ACTIV_NULLPTR == pNewBuffer)
|
|
return STATUS_CODE_HEAP_EMPTY;
|
|
|
|
m_pBuffer = pNewBuffer;
|
|
m_bufferLength = newBufferLength;
|
|
}
|
|
|
|
return STATUS_CODE_SUCCESS;
|
|
}
|
|
|
|
} // namespace Activ
|
|
|
|
#endif // (!defined ACTIV_MISC_SERIALIZABLE_BUFFER_H)
|