/** * @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 ::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 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 inline SerializableBuffer::SerializableBuffer() : m_pData(ACTIV_NULLPTR), m_dataLength(0), m_pBuffer(ACTIV_NULLPTR), m_bufferLength(0) { } // --------------------------------------------------------------------------------------------------------------------------------- template inline SerializableBuffer::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 inline SerializableBuffer::~SerializableBuffer() { if (ACTIV_NULLPTR != m_pBuffer) std::free(m_pBuffer); } // --------------------------------------------------------------------------------------------------------------------------------- template inline SerializableBuffer &SerializableBuffer::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 inline StatusCode SerializableBuffer::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 inline const void *SerializableBuffer::GetData() const { return m_pData; } // --------------------------------------------------------------------------------------------------------------------------------- template inline size_t SerializableBuffer::GetDataLength() const { return m_dataLength; } // --------------------------------------------------------------------------------------------------------------------------------- template inline StatusCode SerializableBuffer::Serialize(MessageBuilder &messageBuilder, const void * const pData, const size_t dataLength) { ACTIV_BOOST_STATIC_ASSERT(Boost::is_unsigned::value); typedef typename Boost::mpl::if_c< (sizeof(LENGTH_TYPE) > sizeof(size_t)), LENGTH_TYPE, size_t >::type MaxLength; if (Less()(dataLength) || (Greater()(dataLength))) return STATUS_CODE_INVALID_LENGTH; ACTIV_RETURN_RESULT_IF_UNLIKELY(STATUS_CODE_SUCCESS, !=, messageBuilder.Append(static_cast(dataLength))); ACTIV_RETURN_RESULT_IF_UNLIKELY(STATUS_CODE_SUCCESS, !=, messageBuilder.AppendBuffer(pData, dataLength)); return STATUS_CODE_SUCCESS; } // --------------------------------------------------------------------------------------------------------------------------------- template inline StatusCode SerializableBuffer::Serialize(MessageBuilder &messageBuilder) const { return Serialize(messageBuilder, m_pData, m_dataLength); } // --------------------------------------------------------------------------------------------------------------------------------- template template inline StatusCode SerializableBuffer::Deserialize(MessageValidator &messageValidator) { m_pData = ACTIV_NULLPTR; m_dataLength = 0; LENGTH_TYPE dataLength; ACTIV_RETURN_RESULT_IF_UNLIKELY(STATUS_CODE_SUCCESS, !=, (messageValidator.ValidateBinaryIntegralRange(MIN_LENGTH, MAX_LENGTH, dataLength))); if (dataLength > 0) { if (COPY_DATA) { ACTIV_RETURN_RESULT_IF_UNLIKELY(STATUS_CODE_SUCCESS, !=, AdjustBufferSize(static_cast(dataLength))); ACTIV_RETURN_RESULT_IF_UNLIKELY(STATUS_CODE_SUCCESS, !=, messageValidator.ValidateBytesCopy(static_cast(dataLength), m_pBuffer)); m_pData = m_pBuffer; } else { const void *pData = reinterpret_cast(messageValidator.GetMessage()) + messageValidator.GetOffset(); ACTIV_RETURN_RESULT_IF_UNLIKELY(STATUS_CODE_SUCCESS, !=, messageValidator.ValidateBytes(dataLength)); m_pData = pData; } m_dataLength = static_cast(dataLength); } return STATUS_CODE_SUCCESS; } // --------------------------------------------------------------------------------------------------------------------------------- template StatusCode SerializableBuffer::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)