173 lines
5.3 KiB
C++
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)
|