EventMessage.h

 
#pragma once
 
#include <aws/core/Core_EXPORTS.h>
#include <aws/core/utils/event/EventHeader.h>
 
namespace Aws
{
    namespace Utils
    {
        namespace Event
        {
            extern AWS_CORE_API const char EVENT_TYPE_HEADER[];
            extern AWS_CORE_API const char CONTENT_TYPE_HEADER[];
            extern AWS_CORE_API const char MESSAGE_TYPE_HEADER[];
            extern AWS_CORE_API const char ERROR_CODE_HEADER[];
            extern AWS_CORE_API const char ERROR_MESSAGE_HEADER[];
            extern AWS_CORE_API const char EXCEPTION_TYPE_HEADER[];
 
            class AWS_CORE_API Message
            {
            public:
                enum class MessageType
                {
                    UNKNOWN,
                    EVENT,
                    REQUEST_LEVEL_ERROR,
                    REQUEST_LEVEL_EXCEPTION
                };
 
                enum class ContentType
                {
                    UNKNOWN,
                    APPLICATION_OCTET_STREAM,
                    APPLICATION_JSON,
                    TEXT_PLAIN
                };
 
                static MessageType GetMessageTypeForName(const Aws::String& name);
                static Aws::String GetNameForMessageType(MessageType value);
 
                static ContentType GetContentTypeForName(const Aws::String& name);
                static Aws::String GetNameForContentType(ContentType value);
 
 
                void Reset();
 
                inline void SetTotalLength(size_t length)
                {
                    m_totalLength = length;
                    m_eventPayload.reserve(length);
                }
 
                inline size_t GetTotalLength() const { return m_totalLength; }
 
                inline void SetHeadersLength(size_t length) { m_headersLength = length; }
                inline size_t GetHeadersLength() const { return m_headersLength; }
 
                inline void SetPayloadLength(size_t length) { m_payloadLength = length; }
                inline size_t GetPayloadLength() const { return m_payloadLength; }
 
                inline void InsertEventHeader(const Aws::String& headerName, const EventHeaderValue& eventHeaderValue)
                {
                    m_eventHeaders.emplace(Aws::Utils::Event::EventHeaderValuePair(headerName, eventHeaderValue));
                }
 
                inline const Aws::Utils::Event::EventHeaderValueCollection& GetEventHeaders() const { return m_eventHeaders; }
 
                void WriteEventPayload(const unsigned char* data, size_t length);
                void WriteEventPayload(const Aws::Vector<unsigned char>& bits);
                void WriteEventPayload(const Aws::String& bits);
                Aws::Vector<unsigned char>&& GetEventPayloadWithOwnership() { return std::move(m_eventPayload); }
                const Aws::Vector<unsigned char>& GetEventPayload() const { return m_eventPayload; }
                Aws::Vector<unsigned char>& GetEventPayload() { return m_eventPayload; }
                inline Aws::String GetEventPayloadAsString() { return Aws::String(m_eventPayload.begin(), m_eventPayload.end()); }
 
            private:
                size_t m_totalLength = 0;
                size_t m_headersLength = 0;
                size_t m_payloadLength = 0;
 
                Aws::Utils::Event::EventHeaderValueCollection m_eventHeaders;
                Aws::Vector<unsigned char> m_eventPayload;
            };
 
        }
    }
}