file_stream.h

 
#pragma once
 
#include <system/io/stream.h>
#include <system/io/file_mode.h>
#include <system/io/file_access.h>
#include <system/io/file_share.h>
#include <system/io/file_options.h>
#include <system/io/seekorigin.h>
#include <system/reflection.h>
#include <system/nullable.h>
#include <memory>
#include <vector>
 
namespace System { namespace IO {
 
namespace Details { class FileWrapper; }
 
class ASPOSECPP_SHARED_CLASS FileStream : public Stream
{
    RTTI_INFO(System::IO::FileStream, ::System::BaseTypesInfo<System::IO::Stream>);
public:
    static constexpr int32_t DefaultBufferSize = 4096;
 
    ASPOSECPP_SHARED_API FileStream(const String& path, FileMode mode);
 
    ASPOSECPP_SHARED_API FileStream(const String& path, FileMode mode, FileAccess access,
               FileShare share = FileShare::Read,
               int32_t buffer_size = DefaultBufferSize,
               FileOptions options = FileOptions::SequentialScan);
 
    ASPOSECPP_SHARED_API FileStream(const String& path, FileMode mode, FileAccess access, FileShare share,
                                    int32_t buffer_size, bool useAsync);
 
    ASPOSECPP_SHARED_API ~FileStream();
 
    FileStream(const FileStream&) = delete;
    FileStream& operator=(const FileStream&) = delete;
 
    ASPOSECPP_SHARED_API bool get_CanRead() const override;
 
    ASPOSECPP_SHARED_API bool get_CanSeek() const override;
 
    ASPOSECPP_SHARED_API bool get_CanWrite() const override;
 
    ASPOSECPP_SHARED_API int64_t get_Length() const override;
 
    ASPOSECPP_SHARED_API String get_Name() const;
 
    ASPOSECPP_SHARED_API void set_Position(int64_t value) override;
 
    ASPOSECPP_SHARED_API int64_t get_Position() const override;
 
    ASPOSECPP_SHARED_API void Close() override;
 
    ASPOSECPP_SHARED_API void Flush() override;
 
    ASPOSECPP_SHARED_API TaskPtr FlushAsync(const Threading::CancellationToken& cancellationToken) override;
 
    ASPOSECPP_SHARED_API void Flush(bool flush_to_disk);
 
    ASPOSECPP_SHARED_API int32_t ReadByte() override;
 
    ASPOSECPP_SHARED_API int32_t Read(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count) override;
 
    ASPOSECPP_SHARED_API RTaskPtr<int32_t> ReadAsync(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count,
                                                     const Threading::CancellationToken& cancellationToken) override;
 
    ASPOSECPP_SHARED_API int64_t Seek(int64_t offset, SeekOrigin origin) override;
 
    ASPOSECPP_SHARED_API void SetLength(int64_t value) override;
 
    ASPOSECPP_SHARED_API void WriteByte(uint8_t value) override;
 
    ASPOSECPP_SHARED_API void Write(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count) override;
 
    ASPOSECPP_SHARED_API TaskPtr WriteAsync(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count,
                                            const Threading::CancellationToken& cancellationToken) override;
 
    ASPOSECPP_SHARED_API int32_t Read(const System::Details::ArrayView<uint8_t>& buffer, int32_t offset, int32_t count) override;
 
    ASPOSECPP_SHARED_API void Write(const System::Details::ArrayView<uint8_t>& buffer, int32_t offset, int32_t count) override;
 
private:
    std::unique_ptr<Details::FileWrapper> m_file;
 
    String m_path;
 
    const FileMode m_mode; // Used only for debugging
 
    const FileAccess m_access;
 
    const FileShare m_share; // Used only for debugging
 
    const FileOptions m_options; // Used only for debugging
 
    std::vector<uint8_t> m_buffer;
 
    const int32_t m_buffer_size;
 
    int32_t m_write_pos = 0;
 
    int32_t m_read_pos = 0;
 
    int32_t m_read_length = 0;
 
    int64_t m_file_pos = 0;
 
    int64_t m_file_start_pos = 0;
 
    void VerifyIntegrity() const;
    void VerifyOpen() const;
    void VerifyReadable() const;
    void VerifyWriteable() const;
    void VerifySeekable() const;
 
    void FlushReadBuffer();
 
    void FlushWriteBuffer();
 
    void FlushInternalBuffers();
 
    void FillReadBuffer();
 
    void CloseInternal();
};
 
}} // namespace System::IO