file.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_FILE_HEADER
#define LIBFILEZILLA_FILE_HEADER
 
#include "fsresult.hpp"
#include "libfilezilla.hpp"
 
#ifdef FZ_WINDOWS
#include "glue/windows.hpp"
#endif

 
#include <stdint.h>
 
namespace fz {
 
class buffer;
class datetime;
class secure_buffer;

class FZ_PUBLIC_SYMBOL file final
{
public:
#ifdef FZ_WINDOWS
    typedef HANDLE file_t;
#else
    typedef int file_t;
#endif

    enum mode {
        reading,
        writing,
        readwrite,
        appending,
    };

    enum creation_flags {
        existing = 0x1,

        empty = 0x2,

        current_user_only = 0x4,

        current_user_and_admins_only = 0x8,

        fresh = 0x10,

        nocreate = 0x20
    };
 
    file() = default;
    file(native_string const& f, mode m, creation_flags d = existing);
 

    explicit file(file_t fd);
 
    ~file();
 
    file(file const&) = delete;
    file& operator=(file const&) = delete;
 
    file(file && op) noexcept;
    file& operator=(file && op) noexcept;
 
    bool opened() const;
    explicit operator bool() const { return opened(); }
 
    /*
     * \brief Opens the named file with the given mode
     *
     * If a (different) file was already opened, it is closed prior to opening the new file.
     */
    result open(native_string const& f, mode m, creation_flags d = existing);
 
    void close();

    file_t fd() {
        return fd_;
    }
 
    file_t detach();

    enum seek_mode {
        begin,

        current,

        end
    };

    int64_t size() const;

    int64_t seek(int64_t offset, seek_mode m);

    int64_t position() { return seek(0, current); }

    bool truncate();

    rwresult read2(void *buf, size_t count);
 
    [[deprecated]]
    inline int64_t read(void *buf, int64_t count) {
        rwresult res = read2(buf, static_cast<size_t>(count));
        return res ? res.value_ : -1;
    }

    rwresult write2(void const* buf, size_t count);
 
    [[deprecated]]
    inline int64_t write(void const* buf, int64_t count) {
        rwresult res = write2(buf, static_cast<size_t>(count));
        return res ? res.value_ : -1;
    }

    bool fsync();

    bool set_modification_time(datetime const& t);

    datetime get_modification_time() const;
 
private:
#ifdef FZ_WINDOWS
    HANDLE fd_{INVALID_HANDLE_VALUE};
#else
    int fd_{-1};
#endif
};


result FZ_PUBLIC_SYMBOL remove_file(native_string const& name, bool missing_file_is_error);

[[deprecated]] inline bool remove_file(native_string const& name) {
    return bool(remove_file(name, false));
}
 
inline file::creation_flags operator|(file::creation_flags lhs, file::creation_flags rhs) {
    return static_cast<file::creation_flags>(static_cast<std::underlying_type_t<file::creation_flags>>(lhs) | static_cast<std::underlying_type_t<file::creation_flags>>(rhs));
}
inline file::creation_flags& operator|=(file::creation_flags & lhs, file::creation_flags rhs) {
    lhs = lhs | rhs;
    return lhs;
}

rwresult FZ_PUBLIC_SYMBOL read_file(fz::file & f, buffer & out, size_t max_size);
rwresult FZ_PUBLIC_SYMBOL read_file(fz::file & f, secure_buffer & out, size_t max_size);

result FZ_PUBLIC_SYMBOL read_file(native_string const& name, buffer & b, size_t max_size);
result FZ_PUBLIC_SYMBOL read_file(native_string const& name, secure_buffer & b, size_t max_size);
 
}
#endif