/** * @file include/ActivMiddleware/ActivFramework/HeapMessage.h * * @brief Header file for HeapMessage class. */ #if (!defined ACTIV_FRAMEWORK_HEAP_MESSAGE_H) #define ACTIV_FRAMEWORK_HEAP_MESSAGE_H #include "ActivMiddleware/ActivFramework/External.h" #include "ActivMiddleware/ActivBase/Ip/IpAddress.h" #include "ActivMiddleware/ActivBase/MessageBuilder.h" #include "ActivMiddleware/ActivBase/ScatterBufferHelper.h" #include "ActivMiddleware/ActivBase/StatusCodeException.h" #include "ActivMiddleware/ActivFramework/Address.h" #include "ActivMiddleware/ActivFramework/IHeap.h" #include "ActivMiddleware/ActivFramework/MessageImpl.h" #include "ActivMiddleware/ActivFramework/RequestId.h" #include "ActivMiddleware/ActivFramework/Subject.h" #include ACTIV_BOOST_INCLUDE(move/move.hpp) #include ACTIV_BOOST_INCLUDE(utility/explicit_operator_bool.hpp) //! Activ namespace. namespace Activ { class Heap; class HeapPool; // --------------------------------------------------------------------------------------------------------------------------------- /** * @brief Heap message class. */ class HeapMessage { public: //! Heap message iterator class. class Iterator { public: //! Default constructor. Iterator(); /** * @brief Dereference operator. * * @return Reference to the current message. */ MessageImpl &operator*(); /** * @brief Member access operator. * * @return Pointer to the current message. */ MessageImpl *operator->(); /** * @brief Prefix increment operator. * * @return Reference to the updated object. */ Iterator &operator++(); /** * @brief Postfix increment operator. * * @return Copy of the original object. */ const Iterator operator++(int); /** * @brief Equality operator. * * @param rhs the object to test against. * * @return whether the two objects are equal. */ bool operator==(const Iterator &rhs) const; /** * @brief Inequality operator. * * @param rhs the object to test against. * * @return whether the two objects are not equal. */ bool operator!=(const Iterator &rhs) const; //! Get pointer to the underlying buffer. const void *GetData() const; //! Get the size of the underlying buffer. Note, this is not necessarily how much data is populated! size_t GetSize() const; private: /** * @brief Constructor. * * @param heapMessage the underlying heap message object. * @param pMessage the current message object. */ ACTIV_FRAMEWORK_API Iterator(const HeapMessage &heapMessage, MessageImpl *pMessage); //! Slow-path of increment operator. ACTIV_FRAMEWORK_API void InternalIncrementOperator(); const HeapMessage *m_pHeapMessage; ///< Underlying HeapMessage object. MessageImpl *m_pMessage; ///< Current message object. friend class HeapMessage; }; //! HeapMessage stateful copy helper class. class StatefulCopyHelper : private Boost::noncopyable { public: //! Default constructor. StatefulCopyHelper(); /** * @brief Constructor. * * @param heapMessage */ StatefulCopyHelper(const HeapMessage &heapMessage); /** * @brief Initialize with a new HeapMessage object. * * @param heapMessage */ void Initialize(const HeapMessage &heapMessage); /** * @brief Copy data from the HeapMessage. * * @param pData the address to copy to. * @param dataLength the length to copy. * * @retval STATUS_CODE_SUCCESS * @retval STATUS_CODE_INVALID_PARAMETER dataLength + the current offset is greater than the HeapMessage's GetLength(). */ ACTIV_FRAMEWORK_API StatusCode operator()(void *pData, const size_t dataLength); private: const HeapMessage * m_pHeapMessage; ///< Underlying HeapMessage object. Iterator m_iterator; ///< Iterator (used for caching current position). size_t m_heapMessageOffset; ///< Offset within the HeapMessage object. size_t m_messageImplOffset; ///< Offset within the current iterated to message object. }; //! Info for a single HeapMessage, ignoring chaining. class Stats { public: HeapId m_heapId; MessageId m_messageId; BucketId m_bucketId; MessageType m_type; StatusCode m_statusCode; Address m_sourceAddress; Address m_destinationAddress; Address m_returnAddress; IpAddress m_ipAddress; RequestId m_requestId; Subject m_subject; size_t m_totalSpace; size_t m_freeSpace; String m_hexDump; ///< Hex dump of message body. }; //! Default Constructor. HeapMessage(); /** * @brief Get a message or chain of messages from a heap. * * @param heap the heap to allocate from. * @param size the number of bytes the message needs to hold. * * This does not throw on heap allocation failures. Use "operator!" or "operator bool" to check for allocation * after construction. */ HeapMessage(IHeap &heap, const size_t size); /** * @brief Get a message or chain of messages from a heap and copy data in. * * @param heap the heap to allocate from. * @param pData pointer to data to copy into the message. * @param dataLength the number of bytes the messages needs to hold and the number of bytes from @a pData copied in. * * This does not throw on heap allocation failures. Use "operator!" or "operator bool" to check for allocation * after construction. */ HeapMessage(IHeap &heap, const void *pData, size_t dataLength); /** * @brief Get a message or chain of messages from a heap, copy data in and block if the heap is empty. * * @param heap the heap to allocate from. * @param pData pointer to data to copy into the message. * @param dataLength the number of bytes the messages needs to hold and the number of bytes from @a pData copied in. * @param timeoutPeriod maximum time to wait for a message allocation to succeed if the heap is empty. * * This does not throw on heap allocation failures. Use "operator!" or "operator bool" to check for allocation * after construction. */ HeapMessage(IHeap &heap, const void *pData, size_t dataLength, const TimeoutPeriod timeoutPeriod); /** * @brief Get a message or chain of messages from a heap and copy data in. * * @param heap the heap to allocate from. * @param messageBuilder containing the data to copy in to the message. * * This does not throw on heap allocation failures. Use "operator!" or "operator bool" to check for allocation * after construction. */ HeapMessage(IHeap &heap, const MessageBuilder &messageBuilder); /** * @brief Move constructor. * * @param rhs transfer ownership of the underlying message managed by @a rhs to this. Note any pointers from the Get() * family of functions on @a rhs should be considered invalid after moving to @a this. */ HeapMessage(ACTIV_BOOST_RV_REF(HeapMessage) rhs) : m_pMessage(rhs.m_pMessage), m_pHeap(rhs.m_pHeap) { // Inline here for G++. rhs.Release(); } //! Destructor. ~HeapMessage(); //! Return a message to its heap (if one is attached). void Return(); /** * @brief Move assignment operator. * * @param rhs transfer ownership of the underlying message managed by @a rhs to this. Note any pointers from the Get() * family of functions on @a rhs should be considered invalid after moving to @a this. * * @return a reference to this object. */ HeapMessage &operator=(ACTIV_BOOST_RV_REF(HeapMessage) rhs) { // Inline here for G++. if (ACTIV_LIKELY(this != &rhs)) { // Assume generally not assigning to a HeapMessage with a MessageImpl already assigned. if (ACTIV_UNLIKELY(0 != m_pMessage)) InternalReturn(); m_pMessage = rhs.m_pMessage; m_pHeap = rhs.m_pHeap; rhs.Release(); } return *this; } //! Is the underlying buffer contiguous (i.e. is this not a chain of messages)? bool IsContiguous() const; //! Get the heap id. HeapId GetHeapId() const; //! Get the message type. MessageType GetType() const; //! Set the message type. void SetType(const MessageType type); //! Get the message status code. StatusCode GetStatusCode() const; //! Set the message status code. void SetStatusCode(const StatusCode statusCode); //! Set the message status code. void SetStatusCode(const StatusCodeErrc statusCode); //! Get the source address. Address &GetSourceAddress() const; //! Set the source address. void SetSourceAddress(const Address &sourceAddress); //! Get the destination address. Address &GetDestinationAddress() const; //! Set the destination address. void SetDestinationAddress(const Address &destinationAddress); //! Get the return address. Address &GetReturnAddress() const; //! Set the return address. void SetReturnAddress(const Address &returnAddress); //! Get the ip address. IpAddress &GetIpAddress() const; //! Set the ip address. void SetIpAddress(const IpAddress &ipAddress); //! Get the request id. RequestId &GetRequestId() const; //! Set the request id. void SetRequestId(const RequestId &requestId); //! Get a reference to the message subject. Subject &GetSubject() const; //! Set the message subject. void SetSubject(const Subject &subject); //! Get the current maximum message length (you can always Extend() if it insufficient). size_t GetCapacity() const; /** * @brief Extend the capacity of the message. * * @param size the size to extend the message's capacity by. * * @return STATUS_CODE_SUCCESS or an error status. */ ACTIV_FRAMEWORK_API StatusCode Extend(const size_t size); //! Get the message length. size_t GetLength() const; //! Get the current available space in the message. size_t GetAvailableSpace() const; /** * @brief Increment the message length. * * @param length the amount to increment the message length by. * * @retval STATUS_CODE_SUCCESS * @retval STATUS_CODE_INVALID_PARAMETER cannot increment the length by greater than the current free capacity. * Use Extend() first. */ StatusCode IncrementLength(size_t length); /** * @brief Set the message length. * * @param length the length of the message. * * @retval STATUS_CODE_SUCCESS * @retval STATUS_CODE_INVALID_PARAMETER cannot set a length greater than the current Capacity(). Use Extend() first. */ StatusCode SetLength(size_t length); /** * @brief Append data. * * @param pData the address of the data to append. * @param dataLength the length of the data to append. This message will be Extend()ed as appropriate. * * @return STATUS_CODE_SUCCESS or an error status code. */ StatusCode Append(const void *pData, const size_t dataLength); /** * @brief Append data. * * @param messageBuilder the data to append. This message will be Extend()ed as appropriate. * * @return STATUS_CODE_SUCCESS or an error status. */ StatusCode Append(const MessageBuilder &messageBuilder); /** * @brief Append data. * * @param scatterBufferHelper the data to append. This message will be Extend()ed as appropriate. * * @return STATUS_CODE_SUCCESS or an error status. */ ACTIV_FRAMEWORK_API StatusCode Append(const ScatterBufferHelper &scatterBufferHelper); /** * @brief Copy some data from the beginning of the message to a buffer. * * @param pData the address to copy data to. * @param dataLength the length to copy. The buffer pointed to by @a pData must be at least this big. * * @retval STATUS_CODE_SUCCESS * @retval STATUS_CODE_INVALID_PARAMETER dataLength is greater than GetLength(). */ StatusCode Copy(void *pData, const size_t dataLength) const; /** * @brief Copy all data from the message to a MessageBuilder. * * @param messageBuilder the MessageBuilder to append to. * * @return STATUS_CODE_SUCCESS or an error status. */ ACTIV_FRAMEWORK_API StatusCode Copy(MessageBuilder &messageBuilder) const; /** * @brief Get a MessageValidator initialized with all data. * * If the requested data is in a contiguous block, then no copying is required and the MessageValidator * will be initialized with the HeapMessage's managed buffer. If not, the requested data will be copied into * a separate internally managed contiguous buffer and MessageValidator be initialized with that. * * @param messageValidator reference to the MessageValidator to initialize with the heap message contents. * @param messageVersion the message version to initialize the MessageValidator with. * * @return STATUS_CODE_SUCCESS or an error status. */ StatusCode Get(MessageValidator &messageValidator, const MessageHandler::MessageVersion messageVersion = MessageHandler::MESSAGE_VERSION_UNDEFINED) const; /** * @brief Get a pointer to all data. * * If the requested data is in a contiguous block, then no copying is required and pData * will point to within the HeapMessage's managed buffer. If not, the requested data will be copied into * a separate internally managed contiguous buffer and pData will point to that. * * @param pData reference to the address of the data. * @param dataLength the length of the message. * * @return STATUS_CODE_SUCCESS or an error status. */ StatusCode Get(const void *&pData, size_t &dataLength) const; /** * @brief Get a pointer to all data. * * If the requested data is in a contiguous block, then no copying is required and pData * will point to within the HeapMessage's managed buffer. If not, the requested data will be copied into * either pGetBuffer (if it's non null and @a getBufferSize is big enough) or a separate internally managed buffer * and pData will point to that. * * @param pData reference to the address of the data. * @param dataLength the length of the message. * @param pGetBuffer buffer to be used if data not contiguous. * @param getBufferSize the size of the get buffer. * * @return STATUS_CODE_SUCCESS or an error status. */ StatusCode Get(const void *&pData, size_t &dataLength, void *pGetBuffer, const size_t getBufferSize) const; /** * @brief Get pointers to all data. * * For each buffer this HeapMessage is managing, @a scatterBufferHelper will have the buffer's pointer and length appended. * Generally this will be one buffer, as this HeapMessage will be contiguous. * * @param scatterBufferHelper the ScatterBufferHelper. It is not reset initially. * * @return STATUS_CODE_SUCCESS or an error status. */ StatusCode Get(ScatterBufferHelper &scatterBufferHelper) const; /** * @brief Attach another message to this object. * * @param heapMessage reference to the message to be attached. * * @return STATUS_CODE_SUCCESS or an error status. */ ACTIV_FRAMEWORK_API StatusCode Attach(HeapMessage &heapMessage); /** * @brief Clone another message into this HeapMessage. * * @param sourceHeapMessage reference to the message to be cloned. * @param pHeap heap to get message copy from. Default is same heap as @a sourceHeapMessage. * * @return STATUS_CODE_SUCCESS or an error status. */ ACTIV_FRAMEWORK_API StatusCode Clone(const HeapMessage &sourceHeapMessage, IHeap * const pHeap = 0); /** * @brief Clone another message into this HeapMessage. * * @param sourceHeapMessage reference to the message to be cloned. * @param heapPool to get message copy from. * * @return STATUS_CODE_SUCCESS or an error status. */ ACTIV_FRAMEWORK_API StatusCode Clone(const HeapMessage &sourceHeapMessage, HeapPool &heapPool); /** * @brief Build a hex dump of a message contents. * * @param bytesPerLine number of bytes to display per line. * * @return Formatted hex dump of the message. */ ACTIV_FRAMEWORK_API String ToHexDumpString(const size_t bytesPerLine = 16) const; //! Get an iterator to the first buffer in the message chain. Iterator Begin() const; //! Get an iterator that points to beyond the last buffer in the message chain. Iterator End() const; //! Is a message attached to this object? ACTIV_BOOST_EXPLICIT_OPERATOR_BOOL() //! Is a message not attached to this object? bool operator!() const; private: ACTIV_BOOST_MOVABLE_BUT_NOT_COPYABLE(HeapMessage) // Undefined. bool operator==(const HeapMessage &rhs) const; bool operator!=(const HeapMessage &rhs) const; //! Release the message pointer. void Release(); //! Return the attached message to its heap. ACTIV_FRAMEWORK_API void InternalReturn(); /** * @brief Append data. * * @param pData the address of the data to append. * @param dataLength the length of the data to append. This message will be Extend()ed as appropriate. * * @return STATUS_CODE_SUCCESS or an error status code. */ ACTIV_FRAMEWORK_API StatusCode InternalAppend(const void *pData, const size_t dataLength); /** * @brief Copy some data from the beginning of the message to a buffer. * * @param pData the address to copy data to. * @param dataLength the length to copy. The buffer pointed to by @a pData must be at least this big. * * @retval STATUS_CODE_SUCCESS * @retval STATUS_CODE_INVALID_PARAMETER dataLength is greater than GetLength(). */ ACTIV_FRAMEWORK_API StatusCode InternalCopy(void *pData, const size_t dataLength) const; /** * @brief Get pointers to all data. * * For each buffer this HeapMessage is managing, @a scatterBufferHelper will have the buffer's pointer and length appended. * Generally this will be one buffer, as this HeapMessage will be contiguous. * * @param scatterBufferHelper the ScatterBufferHelper. It is not reset initially. * * @return STATUS_CODE_SUCCESS or an error status. */ ACTIV_FRAMEWORK_API StatusCode InternalGet(ScatterBufferHelper &scatterBufferHelper) const; /** * @brief Internal clone. Clone another message into this HeapMessage. * * @param sourceHeapMessage reference to the message to be cloned. * @param clonedHeapMessage intermediate message to use while cloning. * * @return STATUS_CODE_SUCCESS or an error status. */ ACTIV_FRAMEWORK_API StatusCode InternalClone(const HeapMessage &sourceHeapMessage, HeapMessage &clonedHeapMessage); MessageImpl * m_pMessage; ///< Underlying message. Heap * m_pHeap; mutable Boost::scoped_ptr m_pReadBuffer; ///< For Get() type calls when HeapMessage is not contiguous. friend class HeapMessageAccessor; }; // --------------------------------------------------------------------------------------------------------------------------------- inline HeapMessage::HeapMessage() : m_pMessage(0), m_pHeap(0) { } // --------------------------------------------------------------------------------------------------------------------------------- inline HeapMessage::HeapMessage(IHeap &heap, const size_t size) : m_pMessage(0), m_pHeap(0) { heap.GetMessage(size, *this); } // --------------------------------------------------------------------------------------------------------------------------------- inline HeapMessage::HeapMessage(IHeap &heap, const void *pData, size_t dataLength) : m_pMessage(0), m_pHeap(0) { heap.GetMessage(pData, dataLength, *this); } // --------------------------------------------------------------------------------------------------------------------------------- inline HeapMessage::HeapMessage(IHeap &heap, const void *pData, size_t dataLength, const TimeoutPeriod timeoutPeriod) : m_pMessage(0), m_pHeap(0) { heap.GetMessage(pData, dataLength, timeoutPeriod, *this); } // --------------------------------------------------------------------------------------------------------------------------------- inline HeapMessage::HeapMessage(IHeap &heap, const MessageBuilder &messageBuilder) : m_pMessage(0), m_pHeap(0) { heap.GetMessage(messageBuilder, *this); } // --------------------------------------------------------------------------------------------------------------------------------- inline HeapMessage::~HeapMessage() { Return(); } // --------------------------------------------------------------------------------------------------------------------------------- inline void HeapMessage::Return() { if (0 != m_pMessage) InternalReturn(); } // --------------------------------------------------------------------------------------------------------------------------------- inline bool HeapMessage::IsContiguous() const { return (MessageKey::INVALID_MESSAGE_ID == m_pMessage->m_continuationMessageId); } // --------------------------------------------------------------------------------------------------------------------------------- inline HeapId HeapMessage::GetHeapId() const { return m_pMessage->m_thisMessage.GetHeapId(); } // --------------------------------------------------------------------------------------------------------------------------------- inline MessageType HeapMessage::GetType() const { return m_pMessage->m_type; } // --------------------------------------------------------------------------------------------------------------------------------- inline void HeapMessage::SetType(const MessageType type) { m_pMessage->m_type = type; } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode HeapMessage::GetStatusCode() const { return m_pMessage->m_statusCode; } // --------------------------------------------------------------------------------------------------------------------------------- inline void HeapMessage::SetStatusCode(const StatusCode statusCode) { m_pMessage->m_statusCode = statusCode; } // --------------------------------------------------------------------------------------------------------------------------------- inline void HeapMessage::SetStatusCode(const StatusCodeErrc statusCode) { m_pMessage->m_statusCode = Boost::underlying_cast(statusCode); } // --------------------------------------------------------------------------------------------------------------------------------- inline Address &HeapMessage::GetSourceAddress() const { return m_pMessage->m_sourceAddress; } // --------------------------------------------------------------------------------------------------------------------------------- inline void HeapMessage::SetSourceAddress(const Address &sourceAddress) { m_pMessage->m_sourceAddress = sourceAddress; } // --------------------------------------------------------------------------------------------------------------------------------- inline Address &HeapMessage::GetDestinationAddress() const { return m_pMessage->m_destinationAddress; } // --------------------------------------------------------------------------------------------------------------------------------- inline void HeapMessage::SetDestinationAddress(const Address &destinationAddress) { m_pMessage->m_destinationAddress = destinationAddress; } // --------------------------------------------------------------------------------------------------------------------------------- inline Address &HeapMessage::GetReturnAddress() const { return m_pMessage->m_returnAddress; } // --------------------------------------------------------------------------------------------------------------------------------- inline void HeapMessage::SetReturnAddress(const Address &returnAddress) { m_pMessage->m_returnAddress = returnAddress; } // --------------------------------------------------------------------------------------------------------------------------------- inline IpAddress &HeapMessage::GetIpAddress() const { return m_pMessage->m_ipAddress; } // --------------------------------------------------------------------------------------------------------------------------------- inline void HeapMessage::SetIpAddress(const IpAddress &ipAddress) { m_pMessage->m_ipAddress = ipAddress; } // --------------------------------------------------------------------------------------------------------------------------------- inline RequestId &HeapMessage::GetRequestId() const { return m_pMessage->m_requestId; } // --------------------------------------------------------------------------------------------------------------------------------- inline void HeapMessage::SetRequestId(const RequestId &requestId) { m_pMessage->m_requestId = requestId; } // --------------------------------------------------------------------------------------------------------------------------------- inline Subject &HeapMessage::GetSubject() const { return m_pMessage->m_subject; } // --------------------------------------------------------------------------------------------------------------------------------- inline void HeapMessage::SetSubject(const Subject &subject) { m_pMessage->m_subject = subject; } // --------------------------------------------------------------------------------------------------------------------------------- inline size_t HeapMessage::GetCapacity() const { return m_pMessage->m_totalSpace; } // --------------------------------------------------------------------------------------------------------------------------------- inline size_t HeapMessage::GetLength() const { return (m_pMessage->m_totalSpace - m_pMessage->m_freeSpace); } // --------------------------------------------------------------------------------------------------------------------------------- inline size_t HeapMessage::GetAvailableSpace() const { return m_pMessage->m_freeSpace; } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode HeapMessage::IncrementLength(size_t length) { if (ACTIV_LIKELY(length <= m_pMessage->m_freeSpace)) { m_pMessage->m_freeSpace -= static_cast(length); return STATUS_CODE_SUCCESS; } else { return STATUS_CODE_INVALID_PARAMETER; } } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode HeapMessage::SetLength(size_t length) { if (ACTIV_LIKELY(length <= m_pMessage->m_totalSpace)) { m_pMessage->m_freeSpace = m_pMessage->m_totalSpace - static_cast(length); return STATUS_CODE_SUCCESS; } else { return STATUS_CODE_INVALID_PARAMETER; } } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode HeapMessage::Append(const void *pData, const size_t dataLength) { size_t messageImplOffset = GetLength(); const size_t newLength = messageImplOffset + dataLength; if (ACTIV_LIKELY(IsContiguous()) && ACTIV_LIKELY(newLength <= m_pMessage->m_size)) { byte_t * const pDestination = const_cast(reinterpret_cast(m_pMessage->GetDataPointer()) + messageImplOffset); MemoryCopy(pDestination, pData, dataLength); return SetLength(newLength); } else { return InternalAppend(pData, dataLength); } } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode HeapMessage::Append(const MessageBuilder &messageBuilder) { return Append(messageBuilder.GetMessage(), messageBuilder.GetLength()); } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode HeapMessage::Copy(void *pData, const size_t dataLength) const { const size_t messageLength = GetLength(); if (ACTIV_UNLIKELY(dataLength > messageLength)) return STATUS_CODE_INVALID_PARAMETER; if (ACTIV_LIKELY(IsContiguous())) { MemoryCopy(pData, m_pMessage->GetDataPointer(), GetMinimum(dataLength, messageLength)); return STATUS_CODE_SUCCESS; } else { return InternalCopy(pData, dataLength); } } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode HeapMessage::Get(MessageValidator &messageValidator, const MessageHandler::MessageVersion messageVersion) const { const void *pData; size_t dataLength; ACTIV_RETURN_RESULT_IF_UNLIKELY(STATUS_CODE_SUCCESS, !=, Get(pData, dataLength)); messageValidator.Initialize(pData, dataLength, messageVersion); return STATUS_CODE_SUCCESS; } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode HeapMessage::Get(const void *&pData, size_t &dataLength) const { const size_t length = GetLength(); if (ACTIV_LIKELY(IsContiguous())) { pData = m_pMessage->GetDataPointer(); } else { if (m_pReadBuffer) m_pReadBuffer->Reset(); else m_pReadBuffer.reset(new MessageBuilder(length)); ACTIV_RETURN_RESULT_IF_UNLIKELY(STATUS_CODE_SUCCESS, !=, Copy(*m_pReadBuffer)); pData = m_pReadBuffer->GetMessage(); } dataLength = length; return STATUS_CODE_SUCCESS; } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode HeapMessage::Get(const void *&pData, size_t &dataLength, void *pGetBuffer, const size_t getBufferSize) const { const size_t length = GetLength(); if (ACTIV_LIKELY(IsContiguous())) { pData = m_pMessage->GetDataPointer(); } else { if ((0 != pGetBuffer) && (getBufferSize >= length)) { ACTIV_RETURN_RESULT_IF_UNLIKELY(STATUS_CODE_SUCCESS, !=, Copy(pGetBuffer, length)); pData = pGetBuffer; } else { if (m_pReadBuffer) m_pReadBuffer->Reset(); else m_pReadBuffer.reset(new MessageBuilder(length)); ACTIV_RETURN_RESULT_IF_UNLIKELY(STATUS_CODE_SUCCESS, !=, Copy(*m_pReadBuffer)); pData = m_pReadBuffer->GetMessage(); } } dataLength = length; return STATUS_CODE_SUCCESS; } // --------------------------------------------------------------------------------------------------------------------------------- inline StatusCode HeapMessage::Get(ScatterBufferHelper &scatterBufferHelper) const { if (ACTIV_LIKELY(IsContiguous())) return scatterBufferHelper.Attach(m_pMessage->GetDataPointer(), GetLength()); else return InternalGet(scatterBufferHelper); } // --------------------------------------------------------------------------------------------------------------------------------- inline HeapMessage::Iterator HeapMessage::Begin() const { return Iterator(*this, m_pMessage); } // --------------------------------------------------------------------------------------------------------------------------------- inline HeapMessage::Iterator HeapMessage::End() const { return Iterator(*this, 0); } // --------------------------------------------------------------------------------------------------------------------------------- inline bool HeapMessage::operator!() const { return (0 == m_pMessage); } // --------------------------------------------------------------------------------------------------------------------------------- inline void HeapMessage::Release() { m_pMessage = 0; } // --------------------------------------------------------------------------------------------------------------------------------- inline HeapMessage::Iterator::Iterator() : m_pHeapMessage(0), m_pMessage(0) { } // --------------------------------------------------------------------------------------------------------------------------------- inline HeapMessage::Iterator::Iterator(const HeapMessage &heapMessage, MessageImpl *pMessage) : m_pHeapMessage(&heapMessage), m_pMessage(pMessage) { } // --------------------------------------------------------------------------------------------------------------------------------- inline MessageImpl &HeapMessage::Iterator::operator*() { return *m_pMessage; } // --------------------------------------------------------------------------------------------------------------------------------- inline MessageImpl *HeapMessage::Iterator::operator->() { return m_pMessage; } // --------------------------------------------------------------------------------------------------------------------------------- inline HeapMessage::Iterator &HeapMessage::Iterator::operator++() { if (ACTIV_LIKELY(MessageKey::INVALID_MESSAGE_ID == m_pMessage->m_continuationMessageId)) m_pMessage = 0; else InternalIncrementOperator(); return *this; } // --------------------------------------------------------------------------------------------------------------------------------- inline const HeapMessage::Iterator HeapMessage::Iterator::operator++(int) { Iterator oldValue = *this; ++(*this); return oldValue; } // --------------------------------------------------------------------------------------------------------------------------------- inline bool HeapMessage::Iterator::operator==(const HeapMessage::Iterator &rhs) const { return ((m_pHeapMessage == rhs.m_pHeapMessage) && (m_pMessage == rhs.m_pMessage)); } // --------------------------------------------------------------------------------------------------------------------------------- inline bool HeapMessage::Iterator::operator!=(const HeapMessage::Iterator &rhs) const { return !((*this) == rhs); } // --------------------------------------------------------------------------------------------------------------------------------- inline const void *HeapMessage::Iterator::GetData() const { return m_pMessage->GetDataPointer(); } // --------------------------------------------------------------------------------------------------------------------------------- inline size_t HeapMessage::Iterator::GetSize() const { return m_pMessage->m_size; } // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- inline HeapMessage::StatefulCopyHelper::StatefulCopyHelper() : m_pHeapMessage(0), m_heapMessageOffset(0), m_messageImplOffset(0) { } // --------------------------------------------------------------------------------------------------------------------------------- inline HeapMessage::StatefulCopyHelper::StatefulCopyHelper(const HeapMessage &heapMessage) : m_pHeapMessage(&heapMessage), m_iterator(m_pHeapMessage->Begin()), m_heapMessageOffset(0), m_messageImplOffset(0) { } // --------------------------------------------------------------------------------------------------------------------------------- inline void HeapMessage::StatefulCopyHelper::Initialize(const HeapMessage &heapMessage) { m_pHeapMessage = &heapMessage; m_iterator = m_pHeapMessage->Begin(); m_heapMessageOffset = 0; m_messageImplOffset = 0; } // --------------------------------------------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------------------------------------------- // NB out of place due to IHeap/HeapMessage inter-dependencies. inline void IHeap::GetMessage(const void *pData, const size_t dataLength, HeapMessage &heapMessage) { GetMessage(dataLength, heapMessage); if (ACTIV_LIKELY(heapMessage) && ACTIV_LIKELY(0 != pData)) { if (ACTIV_UNLIKELY(STATUS_CODE_SUCCESS != heapMessage.Append(pData, dataLength))) heapMessage.Return(); } } } // namespace Activ #endif // (!defined ACTIV_FRAMEWORK_HEAP_MESSAGE_H)