file.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FILE_FILE_HPP__
#define NEFORCE_CORE_FILE_FILE_HPP__

 
#include "NeForce/core/exception/error_code.hpp"
#include "NeForce/core/file/file_async.hpp"
#include "NeForce/core/file/file_diff.hpp"
#include "NeForce/core/file/file_info.hpp"
#include "NeForce/core/file/file_locker.hpp"
#include "NeForce/core/file/file_mapper.hpp"
#include "NeForce/core/file/path.hpp"
#include "NeForce/core/memory/unique_ptr.hpp"
NEFORCE_BEGIN_NAMESPACE__


class NEFORCE_API file {
public:
    static constexpr size_t buffer_size = 8192;

    class line_iterator {
    public:
        using value_type = string;                    
        using reference = const string&;              
        using pointer = const string*;                
        using iterator_category = input_iterator_tag; 
        using difference_type = ptrdiff_t;            
 
    private:
        const file* file_ = nullptr;  
        mutable string current_line_; 
 
    public:
        line_iterator() = default;

        explicit line_iterator(const file* f);

        reference operator*() const noexcept { return current_line_; }

        pointer operator->() const noexcept { return &current_line_; }

        line_iterator& operator++();

        line_iterator operator++(int);

        bool operator==(const line_iterator& rhs) const noexcept { return file_ == rhs.file_; }

        bool operator!=(const line_iterator& rhs) const noexcept { return !(*this == rhs); }
    };
 
#ifdef NEFORCE_PLATFORM_WINDOWS
    using size_type = ::DWORD;           
    using difference_type = ::LONGLONG;  
    using native_handle_type = ::HANDLE; 
#else
    using size_type = size_t;        
    using difference_type = ::off_t; 
    using native_handle_type = int;  
#endif

    struct chunk_info {
        difference_type offset; 
        size_type size;         
        size_type index;        
    };
 
private:
    native_handle_type handle_; 
    path path_{};               
    bool opened_ = false;       
    bool append_mode_ = false;  
 
    size_type buffer_size_ = buffer_size;    
    mutable byte_vector read_buffer_{};      
    mutable size_type read_buffer_pos_ = 0;  
    mutable size_type read_buffer_size_ = 0; 
    mutable byte_vector write_buffer_{};     
    mutable size_type write_buffer_pos_ = 0; 
 
    mutable error_code last_error_code_; 
 
    unique_ptr<file_mapper> map_;    
    unique_ptr<file_locker> locker_; 
    unique_ptr<file_info> info_;     
    unique_ptr<file_async> async_;   
 
private:
    void init_sub_objects() noexcept;
    void reset_sub_objects() noexcept;
 
    bool flush_write_buffer() const noexcept;
    bool fill_read_buffer() const;
 
    void set_last_error() const;
 
    void adjust_buffer_size();
 
public:
    file();

    explicit file(path pth, bool append = false, file_access access = file_access::READ_WRITE,
                  file_shared share_mode = file_shared::SHARE_READ, file_creation creation = file_creation::OPEN_EXIST,
                  file_attri attributes = file_attri::NORMAL);
 
    file(const file&) = delete;
    file& operator=(const file&) = delete;

    file(file&& other) noexcept;

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

    ~file();

    bool open(path pth, bool append = false, file_access access = file_access::READ_WRITE,
              file_shared share_mode = file_shared::SHARE_READ_WRITE,
              file_creation creation = file_creation::OPEN_EXIST, file_attri attributes = file_attri::NORMAL);

    bool open(bool append = false, file_access access = file_access::READ_WRITE,
              file_shared share_mode = file_shared::SHARE_READ_WRITE,
              file_creation creation = file_creation::OPEN_EXIST, file_attri attributes = file_attri::NORMAL);

    void close() noexcept;

    bool flush() noexcept;

    size_type write(const string& data, size_type size);

    size_type write(const string& data);

    size_type write(const void* data, size_type size);

    size_type read(void* buffer, size_type size) const;

    size_type read(string& out, size_type size) const;

    size_type read(string& out) const;

    NEFORCE_NODISCARD string read() const;

    size_type read_binary(void* out, size_type size) const;

    size_type read_binary(string& out, size_type size) const;

    size_type read_binary(string& out) const;

    NEFORCE_NODISCARD string read_binary() const;

    bool read_line(string& line) const;

    NEFORCE_NODISCARD string read_line() const;

    NEFORCE_NODISCARD vector<string> read_lines() const;

    vector<string> read_chunks(size_type chunk_size = buffer_size * 16) const;

    bool write_chunks(const vector<string>& chunks);

    NEFORCE_NODISCARD vector<chunk_info> chunks_info(size_type chunk_size) const;

    bool seek(difference_type distance, file_pointer method = file_pointer::END) const;

    difference_type tell() const;

    difference_type system_tell() const;

    bool prefetch(size_type hint_size = 0) const;

    bool truncate(difference_type size) const;

    NEFORCE_NODISCARD size_type size() const;

    bool size(size_type& out_size) const;

    NEFORCE_NODISCARD uint64_t size64() const;

    NEFORCE_NODISCARD native_handle_type native_handle() const noexcept { return handle_; }

    NEFORCE_NODISCARD const path& file_path() const noexcept { return path_; }

    NEFORCE_NODISCARD bool is_opened() const noexcept { return opened_; }

    NEFORCE_NODISCARD bool is_append() const noexcept { return append_mode_; }

    NEFORCE_NODISCARD const error_code& last_error_code() const noexcept { return last_error_code_; }

    void clear_error() noexcept;

    NEFORCE_NODISCARD line_iterator begin_lines() const { return line_iterator(this); }

    NEFORCE_NODISCARD line_iterator end_lines() const { return {}; }

    NEFORCE_NODISCARD file_mapper& mapper() noexcept { return *map_; }
    NEFORCE_NODISCARD const file_mapper& mapper() const noexcept { return *map_; }

    NEFORCE_NODISCARD file_locker& locker() noexcept { return *locker_; }
    NEFORCE_NODISCARD const file_locker& locker() const noexcept { return *locker_; }

    NEFORCE_NODISCARD file_info& info() noexcept { return *info_; }
    NEFORCE_NODISCARD const file_info& info() const noexcept { return *info_; }

    NEFORCE_NODISCARD file_async& async() noexcept { return *async_; }
    NEFORCE_NODISCARD const file_async& async() const noexcept { return *async_; }
};
 // File
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FILE_FILE_HPP__