Stream.h

Go to the documentation of this file.

#pragma once
 
#include <aws/crt/Exports.h>
#include <aws/crt/RefCounted.h>
#include <aws/crt/Types.h>
#include <aws/io/stream.h>
 
namespace Aws
{
    namespace Crt
    {
        namespace Io
        {
            using StreamStatus = aws_stream_status;

            using OffsetType = aws_off_t;

            enum class StreamSeekBasis
            {
                Begin = AWS_SSB_BEGIN,
                End = AWS_SSB_END,
            };
 
            /***
             * Interface for building an Object oriented stream that will be honored by the CRT's low-level
             * aws_input_stream interface. To use, create a subclass of InputStream and define the abstract
             * functions.
             */
            class AWS_CRT_CPP_API InputStream : public std::enable_shared_from_this<InputStream>,
                                                public RefCounted<InputStream>
            {
              public:
                virtual ~InputStream();
 
                InputStream(const InputStream &) = delete;
                InputStream &operator=(const InputStream &) = delete;
                InputStream(InputStream &&) = delete;
                InputStream &operator=(InputStream &&) = delete;
 
                explicit operator bool() const noexcept { return IsValid(); }

                virtual bool IsValid() const noexcept = 0;

                aws_input_stream *GetUnderlyingStream() noexcept { return &m_underlying_stream; }

                bool Read(ByteBuf &dest) { return aws_input_stream_read(&m_underlying_stream, &dest) == 0; }

                bool Seek(int64_t offset, StreamSeekBasis seekBasis)
                {
                    return aws_input_stream_seek(&m_underlying_stream, offset, (aws_stream_seek_basis)seekBasis) == 0;
                }

                bool GetStatus(StreamStatus &status)
                {
                    return aws_input_stream_get_status(&m_underlying_stream, &status) == 0;
                }

                bool GetLength(int64_t &length)
                {
                    return aws_input_stream_get_length(&m_underlying_stream, &length) == 0;
                }
 
              protected:
                Allocator *m_allocator;
                aws_input_stream m_underlying_stream;
 
                InputStream(Aws::Crt::Allocator *allocator = ApiAllocator());
 
                /***
                 * Read up-to buffer::capacity - buffer::len into buffer::buffer
                 * Increment buffer::len by the amount you read in.
                 *
                 * @return true if nothing went wrong.
                 * Return true even if you read 0 bytes because the end-of-file has been reached.
                 * Return true even if you read 0 bytes because data is not currently available.
                 *
                 * Return false if an actual failure condition occurs,
                 * you SHOULD also raise an error via aws_raise_error().
                 */
                virtual bool ReadImpl(ByteBuf &buffer) noexcept = 0;
 
                /***
                 * Read up-to buffer::capacity - buffer::len immediately available bytes into buffer::buffer
                 * Increment buffer::len by the amount you read in.
                 *
                 * @return true if nothing went wrong.
                 * Return true even if you read 0 bytes because the end-of-file has been reached.
                 * Return true even if you read 0 bytes because data is not currently available.
                 *
                 * Return false if an actual failure condition occurs,
                 * you SHOULD also raise an error via aws_raise_error().
                 */
                virtual bool ReadSomeImpl(ByteBuf &buffer) noexcept = 0;

                virtual StreamStatus GetStatusImpl() const noexcept = 0;

                virtual int64_t GetLengthImpl() const noexcept = 0;

                virtual bool SeekImpl(int64_t offset, StreamSeekBasis seekBasis) noexcept = 0;

                virtual int64_t PeekImpl() const noexcept = 0;
 
              private:
                static int s_Seek(aws_input_stream *stream, int64_t offset, enum aws_stream_seek_basis basis);
                static int s_Read(aws_input_stream *stream, aws_byte_buf *dest);
                static int s_GetStatus(aws_input_stream *stream, aws_stream_status *status);
                static int s_GetLength(struct aws_input_stream *stream, int64_t *out_length);
                static void s_Acquire(aws_input_stream *stream);
                static void s_Release(aws_input_stream *stream);
 
                static aws_input_stream_vtable s_vtable;
            };
 
            /***
             * Implementation of Aws::Crt::Io::InputStream that wraps a std::input_stream.
             */
            class AWS_CRT_CPP_API StdIOStreamInputStream : public InputStream
            {
              public:
                StdIOStreamInputStream(
                    std::shared_ptr<Aws::Crt::Io::IStream> stream,
                    Aws::Crt::Allocator *allocator = ApiAllocator()) noexcept;
 
                bool IsValid() const noexcept override;
 
              protected:
                bool ReadImpl(ByteBuf &buffer) noexcept override;
                bool ReadSomeImpl(ByteBuf &buffer) noexcept override;
                StreamStatus GetStatusImpl() const noexcept override;
                int64_t GetLengthImpl() const noexcept override;
                bool SeekImpl(OffsetType offsetType, StreamSeekBasis seekBasis) noexcept override;
                int64_t PeekImpl() const noexcept override;
 
              private:
                std::shared_ptr<Aws::Crt::Io::IStream> m_stream;
            };
        } // namespace Io
    } // namespace Crt
} // namespace Aws