/** * @file include/ActivMiddleware/ActivFramework/HeapMessageBuilder.h * * @brief Header file for heap message / message builder class. */ #if (!defined ACTIV_FRAMEWORK_HEAP_MESSAGE_BUILDER_H) #define ACTIV_FRAMEWORK_HEAP_MESSAGE_BUILDER_H #include "ActivMiddleware/ActivFramework/External.h" #include "ActivMiddleware/ActivBase/MessageBuilder.h" #include "ActivMiddleware/ActivFramework/HeapMessage.h" //! Activ namespace. namespace Activ { /** * @brief Helper class to build directly into a HeapMessage, if possible. */ class HeapMessageBuilder { public: /** * @brief Constructor. * * @param pHeap the heap to get the HeapMessage from. * @param approximateSize the approximate size of the message that will be built. A HeapMessage of size * @a approximateSize will be allocated from @a pHeap. * @param messageVersion optional version passed through to the underlying MessageBuilder. */ HeapMessageBuilder(IHeap * const pHeap, const size_t approximateSize, const MessageBuilder::MessageVersion messageVersion = MessageBuilder::MESSAGE_VERSION_UNDEFINED); /** * @brief Constructor. * * @param heapMessage an existing allocated HeapMessage. If it is contiguous, the MessageBuilder will be * set up initially build in to it directly. * @param approximateSize the approximate size of the message that will be built. If @a heapMessage is not contiguous, * this is the size of the MessageBuilder's initial buffer. * @param messageVersion optional version passed through to the underlying MessageBuilder. */ HeapMessageBuilder(HeapMessage &heapMessage, const size_t approximateSize, const MessageBuilder::MessageVersion messageVersion = MessageBuilder::MESSAGE_VERSION_UNDEFINED); /** * @brief Get the underlying MessageBuilder. * * @return Reference to MessageBuilder. */ MessageBuilder &GetMessageBuilder(); /** * @brief Get the built HeapMessage. * * @return HeapMessage reference. On error, no message will be attached to @a heapMessage * (!heapMessage will return true). */ void GetHeapMessage(HeapMessage &heapMessage); private: //! Initialize. void Initialize(); IHeap * const m_pHeap; HeapMessage m_heapMessage; void * m_pBuffer; size_t m_size; MessageBuilder m_messageBuilder; }; // --------------------------------------------------------------------------------------------------------------------------------- inline HeapMessageBuilder::HeapMessageBuilder(IHeap * const pHeap, const size_t approximateSize, const MessageBuilder::MessageVersion messageVersion) : m_pHeap(pHeap), m_heapMessage(*pHeap, approximateSize), m_pBuffer(0) { if (m_heapMessage) Initialize(); StatusCode statusCode; if (0 != m_pBuffer) statusCode = m_messageBuilder.Initialize(m_pBuffer, m_size, true, messageVersion); else statusCode = m_messageBuilder.Initialize(approximateSize, true, messageVersion); if (STATUS_CODE_SUCCESS != statusCode) ACTIV_THROW(StatusCodeException, statusCode); } // --------------------------------------------------------------------------------------------------------------------------------- inline HeapMessageBuilder::HeapMessageBuilder(HeapMessage &heapMessage, const size_t approximateSize, const MessageBuilder::MessageVersion messageVersion) : m_pHeap(0), m_heapMessage(CxxYZ::move(heapMessage)), m_pBuffer(0) { if (m_heapMessage) Initialize(); else ACTIV_THROW(StatusCodeException, STATUS_CODE_INVALID_PARAMETER); StatusCode statusCode; if (0 != m_pBuffer) statusCode = m_messageBuilder.Initialize(m_pBuffer, m_size, true, messageVersion); else statusCode = m_messageBuilder.Initialize(approximateSize, true, messageVersion); if (STATUS_CODE_SUCCESS != statusCode) ACTIV_THROW(StatusCodeException, statusCode); } // --------------------------------------------------------------------------------------------------------------------------------- inline MessageBuilder &HeapMessageBuilder::GetMessageBuilder() { return m_messageBuilder; } // --------------------------------------------------------------------------------------------------------------------------------- inline void HeapMessageBuilder::GetHeapMessage(HeapMessage &heapMessage) { // If we have a HeapMessage, and the message was built into it in one block, set the length of the HeapMessage. // NB if m_pBuffer is non-null, it must point to a HeapMessage. Hence no check on m_heapMessage being valid. if ((m_messageBuilder.GetMessage() == m_pBuffer) && (STATUS_CODE_SUCCESS == m_heapMessage.SetLength(m_messageBuilder.GetLength()))) { heapMessage = CxxYZ::move(m_heapMessage); } else if (0 != m_pHeap) { m_pHeap->GetMessage(m_messageBuilder, heapMessage); } else { if (STATUS_CODE_SUCCESS == m_heapMessage.Append(m_messageBuilder)) heapMessage = CxxYZ::move(m_heapMessage); } } // --------------------------------------------------------------------------------------------------------------------------------- inline void HeapMessageBuilder::Initialize() { assert(m_heapMessage); if (ACTIV_LIKELY(m_heapMessage.IsContiguous())) { // HeapMessage is contiguous, store pointer and length of one and only block. const HeapMessage::Iterator iter = m_heapMessage.Begin(); m_pBuffer = const_cast(iter.GetData()); m_size = iter.GetSize(); } else { m_pBuffer = 0; m_size = 0; } } } // namespace Activ #endif // (!defined ACTIV_FRAMEWORK_HEAP_MESSAGE_BUILDER_H)