Files

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)