file_async.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FILE_FILE_ASYNC_HPP__
#define NEFORCE_CORE_FILE_FILE_ASYNC_HPP__

 
#include "NeForce/core/async/cancellation_slot.hpp"
#include "NeForce/core/async/io_context.hpp"
#include "NeForce/core/exception/error_code.hpp"
#include "NeForce/core/file/file_constants.hpp"
#include "NeForce/core/string/string.hpp"
NEFORCE_BEGIN_NAMESPACE__


class NEFORCE_API file_async {
public:
#ifdef NEFORCE_PLATFORM_WINDOWS
    using size_type = ::DWORD;          
    using difference_type = ::LONGLONG; 
#else
    using size_type = size_t;        
    using difference_type = ::off_t; 
#endif
    using native_handle_type = _NEFORCE native_handle_type; 
 
private:
    native_handle_type handle_;
    io_context* ctx_{nullptr};
#ifdef NEFORCE_USING_IO_URING
    struct uring;
    unique_ptr<uring> uring_;
#endif
    function<void(error_code, size_type)> pending_handler_;
 
    void ensure_iocp(io_context& ctx);
 
    void do_async_read(io_context& ctx, string& buffer, size_type size, difference_type offset, cancellation_slot* slot,
                       function<void(error_code, size_type)> handler);
 
    void do_async_write(io_context& ctx, string data, size_type size, difference_type offset, cancellation_slot* slot,
                        function<void(error_code, size_type)> handler);
 
public:
    explicit file_async(native_handle_type handle);

    ~file_async();
 
    file_async(const file_async&) = delete;
    file_async& operator=(const file_async&) = delete;

    file_async(file_async&& other) noexcept;

    file_async& operator=(file_async&& other) noexcept;

    void async_read(io_context& ctx, string& buffer, size_type size, function<void(error_code, size_type)> handler) {
        do_async_read(ctx, buffer, size, -1, nullptr, move(handler));
    }

    void async_read(io_context& ctx, string& buffer, size_type size, difference_type offset,
                    function<void(error_code, size_type)> handler) {
        do_async_read(ctx, buffer, size, offset, nullptr, move(handler));
    }

    void async_read(io_context& ctx, string& buffer, size_type size, cancellation_slot& slot,
                    function<void(error_code, size_type)> handler) {
        do_async_read(ctx, buffer, size, -1, &slot, move(handler));
    }

    void async_write(io_context& ctx, string data, size_type size, function<void(error_code, size_type)> handler) {
        do_async_write(ctx, move(data), size, -1, nullptr, move(handler));
    }

    void async_write(io_context& ctx, string data, size_type size, difference_type offset,
                     function<void(error_code, size_type)> handler) {
        do_async_write(ctx, move(data), size, offset, nullptr, move(handler));
    }

    void async_write(io_context& ctx, string data, size_type size, cancellation_slot& slot,
                     function<void(error_code, size_type)> handler) {
        do_async_write(ctx, move(data), size, -1, &slot, move(handler));
    }

    NEFORCE_NODISCARD native_handle_type native_handle() const noexcept { return handle_; }
};
 // File
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FILE_FILE_ASYNC_HPP__