ChannelHandler.h

Go to the documentation of this file.

#pragma once
#include <aws/crt/Exports.h>
#include <aws/crt/Types.h>
#include <aws/crt/io/EventLoopGroup.h>
#include <aws/io/channel.h>
 
#include <chrono>
#include <cstddef>
 
struct aws_array_list;
struct aws_io_message;
 
namespace Aws
{
    namespace Crt
    {
        namespace Io
        {
            enum class ChannelDirection
            {
                Read,
                Write,
            };
 
            enum class MessageType
            {
                ApplicationData,
            };
 
            class AWS_CRT_CPP_API ChannelHandler
            {
              public:
                virtual ~ChannelHandler() = default;
 
                ChannelHandler(const ChannelHandler &) = delete;
                ChannelHandler &operator=(const ChannelHandler &) = delete;
 
              protected:
                virtual int ProcessReadMessage(struct aws_io_message *message) = 0;
 
                virtual int ProcessWriteMessage(struct aws_io_message *message) = 0;
 
                virtual int IncrementReadWindow(size_t size) = 0;
 
                virtual void ProcessShutdown(
                    ChannelDirection dir,
                    int errorCode,
                    bool freeScarceResourcesImmediately) = 0;
 
                virtual size_t InitialWindowSize() = 0;
 
                virtual size_t MessageOverhead() = 0;
 
                virtual void ResetStatistics() {};
 
                virtual void GatherStatistics(struct aws_array_list *) {}
 
              public:
                struct aws_channel_handler *SeatForCInterop(const std::shared_ptr<ChannelHandler> &selfRef);
 
                bool ChannelsThreadIsCallersThread() const;
 
                void ShutDownChannel(int errorCode);
 
                void ScheduleTask(std::function<void(TaskStatus)> &&task);
 
                void ScheduleTask(std::function<void(TaskStatus)> &&task, std::chrono::nanoseconds run_in);
 
              protected:
                ChannelHandler(Allocator *allocator = ApiAllocator());
 
                struct aws_io_message *AcquireMessageFromPool(MessageType messageType, size_t sizeHint);
 
                struct aws_io_message *AcquireMaxSizeMessageForWrite();
 
                bool SendMessage(struct aws_io_message *message, ChannelDirection direction);
 
                bool IncrementUpstreamReadWindow(size_t windowUpdateSize);
 
                void OnShutdownComplete(ChannelDirection direction, int errorCode, bool freeScarceResourcesImmediately);
 
                size_t DownstreamReadWindow() const;
 
                size_t UpstreamMessageOverhead() const;
 
                struct aws_channel_slot *GetSlot() const;
 
                struct aws_channel_handler m_handler;
                Allocator *m_allocator;
 
              private:
                std::shared_ptr<ChannelHandler> m_selfReference;
                static struct aws_channel_handler_vtable s_vtable;
 
                static void s_Destroy(struct aws_channel_handler *handler);
                static int s_ProcessReadMessage(
                    struct aws_channel_handler *,
                    struct aws_channel_slot *,
                    struct aws_io_message *);
                static int s_ProcessWriteMessage(
                    struct aws_channel_handler *,
                    struct aws_channel_slot *,
                    struct aws_io_message *);
                static int s_IncrementReadWindow(struct aws_channel_handler *, struct aws_channel_slot *, size_t size);
                static int s_ProcessShutdown(
                    struct aws_channel_handler *,
                    struct aws_channel_slot *,
                    enum aws_channel_direction,
                    int errorCode,
                    bool freeScarceResourcesImmediately);
                static size_t s_InitialWindowSize(struct aws_channel_handler *);
                static size_t s_MessageOverhead(struct aws_channel_handler *);
                static void s_ResetStatistics(struct aws_channel_handler *);
                static void s_GatherStatistics(struct aws_channel_handler *, struct aws_array_list *statsList);
            };
        } // namespace Io
    } // namespace Crt
} // namespace Aws