Files

173 lines
5.3 KiB
C++

/**
* @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<void *>(iter.GetData());
m_size = iter.GetSize();
}
else
{
m_pBuffer = 0;
m_size = 0;
}
}
} // namespace Activ
#endif // (!defined ACTIV_FRAMEWORK_HEAP_MESSAGE_BUILDER_H)