stream.h

 
#ifndef _aspose_system_io_stream_h_
#define _aspose_system_io_stream_h_
 
#include "system/array.h"
#include "system/idisposable.h"
#include "system/io/seekorigin.h"
#include "system/async_callback.h"
 
#include "system/details/array_view.h"
 
#include "system/exceptions.h"
 
namespace System {
    class IAsyncResult;
};
 
namespace System { namespace IO {
class ASPOSECPP_SHARED_CLASS Stream : public System::IDisposable
{
    RTTI_INFO(System::IO::Stream, ::System::BaseTypesInfo<System::IDisposable>)
 
public:
    typedef SharedPtr<Stream> Ptr;
 
    // There no need to define an empty virtual dtor, virtual dtor for inheritance already defined in the Object class
    // virtual ~Stream() {}
    virtual ASPOSECPP_SHARED_API int ReadByte();
    virtual ASPOSECPP_SHARED_API void WriteByte(uint8_t value);
 
    virtual ASPOSECPP_SHARED_API int32_t Read(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count) = 0;
 
    virtual ASPOSECPP_SHARED_API RTaskPtr<int32_t> ReadAsync(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count,
                                                     const Threading::CancellationToken& cancellationToken);
 
    ASPOSECPP_SHARED_API RTaskPtr<int32_t> ReadAsync(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count);
 
    virtual ASPOSECPP_SHARED_API void Write(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count) = 0;
 
    virtual ASPOSECPP_SHARED_API TaskPtr WriteAsync(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count,
                                                    const Threading::CancellationToken& cancellationToken);
 
    ASPOSECPP_SHARED_API TaskPtr WriteAsync(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count);
 
    virtual ASPOSECPP_SHARED_API int32_t Read(const System::Details::ArrayView<uint8_t>& buffer, int32_t offset, int32_t count);
    virtual ASPOSECPP_SHARED_API void Write(const System::Details::ArrayView<uint8_t>& buffer, int32_t offset, int32_t count);
    template<std::size_t N>
    int32_t Read(const System::Details::StackArray<uint8_t, N>& buffer, int32_t offset, int32_t count)
    {
        return Read(static_cast<System::Details::ArrayView<uint8_t>>(buffer), offset, count);
    }
    template<std::size_t N>
    void Write(const System::Details::StackArray<uint8_t, N>& buffer, int32_t offset, int32_t count)
    {
        Write(static_cast<System::Details::ArrayView<uint8_t>>(buffer), offset, count);
    }
 
    virtual ASPOSECPP_SHARED_API int64_t Seek(int64_t offset, SeekOrigin origin) = 0;
    virtual ASPOSECPP_SHARED_API void SetLength(int64_t value) = 0;
    virtual ASPOSECPP_SHARED_API void Flush() = 0;
    virtual ASPOSECPP_SHARED_API TaskPtr FlushAsync(const Threading::CancellationToken& cancellationToken);
    ASPOSECPP_SHARED_API TaskPtr FlushAsync();
    virtual void Close() {}
    ASPOSECPP_SHARED_API void Dispose() override;
 
    virtual ASPOSECPP_SHARED_API System::SharedPtr<System::IAsyncResult> BeginRead(System::ArrayPtr<uint8_t> buffer, int offset, int count, System::AsyncCallback callback, System::SharedPtr<System::Object> state);
    virtual ASPOSECPP_SHARED_API System::SharedPtr<System::IAsyncResult> BeginWrite(System::ArrayPtr<uint8_t> buffer, int offset, int count, System::AsyncCallback callback, System::SharedPtr<System::Object> state);
    virtual ASPOSECPP_SHARED_API int EndRead(System::SharedPtr<System::IAsyncResult> asyncResult);
    virtual ASPOSECPP_SHARED_API void EndWrite(System::SharedPtr<System::IAsyncResult> asyncResult);
 
    ASPOSECPP_SHARED_API void CopyTo(const SharedPtr<Stream>& destination);
 
    ASPOSECPP_SHARED_API void CopyTo(const SharedPtr<Stream>& destination, int32_t buffer_size);
 
    virtual ASPOSECPP_SHARED_API void set_Position(int64_t value) = 0;
    virtual ASPOSECPP_SHARED_API int64_t get_Position() const = 0;
    virtual ASPOSECPP_SHARED_API int64_t get_Length() const = 0;
    virtual ASPOSECPP_SHARED_API bool get_CanRead() const = 0;
    virtual ASPOSECPP_SHARED_API bool get_CanSeek() const = 0;
    virtual ASPOSECPP_SHARED_API bool get_CanWrite() const = 0;
 
    virtual ASPOSECPP_SHARED_API bool get_CanTimeout() const;
    virtual ASPOSECPP_SHARED_API void set_ReadTimeout(int timeout);
 
    virtual ASPOSECPP_SHARED_API int get_ReadTimeout() const;
    virtual ASPOSECPP_SHARED_API void set_WriteTimeout(int timeout);
 
    virtual ASPOSECPP_SHARED_API int get_WriteTimeout() const;
 
    static const System::SharedPtr<Stream> ASPOSECPP_SHARED_API Null;
 
protected:
    virtual ASPOSECPP_SHARED_API void Dispose(bool disposing);
};
 
}} // System::IO
 
#endif // _aspose_system_io_stream_h_