Trait gio::prelude::FileExtManual

pub trait FileExtManual: Sized {
    // Required methods
    fn replace_contents_async<B: AsRef<[u8]> + Send + 'static, R: FnOnce(Result<(B, GString), (B, Error)>) + 'static, C: IsA<Cancellable>>(
        &self,
        contents: B,
        etag: Option<&str>,
        make_backup: bool,
        flags: FileCreateFlags,
        cancellable: Option<&C>,
        callback: R
    );
    fn replace_contents_future<B: AsRef<[u8]> + Send + 'static>(
        &self,
        contents: B,
        etag: Option<&str>,
        make_backup: bool,
        flags: FileCreateFlags
    ) -> Pin<Box<dyn Future<Output = Result<(B, GString), (B, Error)>> + 'static>>;
    fn enumerate_children_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileEnumerator, Error>) + 'static>(
        &self,
        attributes: &'static str,
        flags: FileQueryInfoFlags,
        io_priority: Priority,
        cancellable: Option<&P>,
        callback: Q
    );
    fn enumerate_children_future(
        &self,
        attributes: &'static str,
        flags: FileQueryInfoFlags,
        io_priority: Priority
    ) -> Pin<Box<dyn Future<Output = Result<FileEnumerator, Error>> + 'static>>;
    fn copy_async<Q: FnOnce(Result<(), Error>) + 'static>(
        &self,
        destination: &impl IsA<File>,
        flags: FileCopyFlags,
        io_priority: Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        progress_callback: Option<Box<dyn FnMut(i64, i64)>>,
        callback: Q
    );
    fn copy_future(
        &self,
        destination: &impl IsA<File> + Clone + 'static,
        flags: FileCopyFlags,
        io_priority: Priority
    ) -> (Pin<Box<dyn Future<Output = Result<(), Error>> + 'static>>, Pin<Box<dyn Stream<Item = (i64, i64)> + 'static>>);
    fn load_partial_contents_async<P: FnMut(&[u8]) -> bool + 'static, Q: FnOnce(Result<(Vec<u8>, Option<GString>), Error>) + 'static>(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
        read_more_callback: P,
        callback: Q
    );
    fn measure_disk_usage(
        &self,
        flags: FileMeasureFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
        progress_callback: Option<Box<dyn FnMut(bool, u64, u64, u64) + 'static>>
    ) -> Result<(u64, u64, u64), Error>;
    fn measure_disk_usage_async<P: FnOnce(Result<(u64, u64, u64), Error>) + 'static>(
        &self,
        flags: FileMeasureFlags,
        io_priority: Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        progress_callback: Option<Box<dyn FnMut(bool, u64, u64, u64) + 'static>>,
        callback: P
    );
    fn measure_disk_usage_future(
        &self,
        flags: FileMeasureFlags,
        io_priority: Priority
    ) -> (Pin<Box<dyn Future<Output = Result<(u64, u64, u64), Error>> + 'static>>, Pin<Box<dyn Stream<Item = (bool, u64, u64, u64)> + 'static>>);
    fn move_async<Q: FnOnce(Result<(), Error>) + 'static>(
        &self,
        destination: &impl IsA<File>,
        flags: FileCopyFlags,
        io_priority: Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        progress_callback: Option<Box<dyn FnMut(i64, i64)>>,
        callback: Q
    );
    fn move_future(
        &self,
        destination: &impl IsA<File> + Clone + 'static,
        flags: FileCopyFlags,
        io_priority: Priority
    ) -> (Pin<Box<dyn Future<Output = Result<(), Error>> + 'static>>, Pin<Box<dyn Stream<Item = (i64, i64)> + 'static>>);
}

Required Methods

fn replace_contents_async<B: AsRef<[u8]> + Send + 'static, R: FnOnce(Result<(B, GString), (B, Error)>) + 'static, C: IsA<Cancellable>>( &self, contents: B, etag: Option<&str>, make_backup: bool, flags: FileCreateFlags, cancellable: Option<&C>, callback: R )

Starts an asynchronous replacement of self with the given contents of length bytes. etag will replace the document’s current entity tag.

When this operation has completed, callback will be called with user_user data, and the operation can be finalized with g_file_replace_contents_finish().

If cancellable is not None, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error IOErrorEnum::Cancelled will be returned.

If make_backup is true, this function will attempt to make a backup of self.

Note that no copy of contents will be made, so it must stay valid until callback is called. See g_file_replace_contents_bytes_async() for a glib::Bytes version that will automatically hold a reference to the contents (without copying) for the duration of the call.

contents

string of contents to replace the file with

etag

a new [entity tag][gfile-etag] for the self, or None

make_backup

true if a backup should be created

flags

a set of FileCreateFlags

cancellable

optional Cancellable object, None to ignore

callback

a GAsyncReadyCallback to call when the request is satisfied

fn replace_contents_future<B: AsRef<[u8]> + Send + 'static>( &self, contents: B, etag: Option<&str>, make_backup: bool, flags: FileCreateFlags ) -> Pin<Box<dyn Future<Output = Result<(B, GString), (B, Error)>> + 'static>>

fn enumerate_children_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileEnumerator, Error>) + 'static>( &self, attributes: &'static str, flags: FileQueryInfoFlags, io_priority: Priority, cancellable: Option<&P>, callback: Q )

fn enumerate_children_future( &self, attributes: &'static str, flags: FileQueryInfoFlags, io_priority: Priority ) -> Pin<Box<dyn Future<Output = Result<FileEnumerator, Error>> + 'static>>

fn copy_async<Q: FnOnce(Result<(), Error>) + 'static>( &self, destination: &impl IsA<File>, flags: FileCopyFlags, io_priority: Priority, cancellable: Option<&impl IsA<Cancellable>>, progress_callback: Option<Box<dyn FnMut(i64, i64)>>, callback: Q )

Copies the file self to the location specified by destination asynchronously. For details of the behaviour, see g_file_copy().

If progress_callback is not None, then that function that will be called just like in g_file_copy(). The callback will run in the default main context of the thread calling FileExtManual::copy_async() — the same context as callback is run in.

When the operation is finished, callback will be called. You can then call g_file_copy_finish() to get the result of the operation.

destination

destination File

flags

set of FileCopyFlags

io_priority

the [I/O priority][io-priority] of the request

cancellable

optional Cancellable object, None to ignore

progress_callback

function to callback with progress information, or None if progress information is not needed

progress_callback_data

user data to pass to progress_callback

callback

a GAsyncReadyCallback to call when the request is satisfied

fn copy_future( &self, destination: &impl IsA<File> + Clone + 'static, flags: FileCopyFlags, io_priority: Priority ) -> (Pin<Box<dyn Future<Output = Result<(), Error>> + 'static>>, Pin<Box<dyn Stream<Item = (i64, i64)> + 'static>>)

fn load_partial_contents_async<P: FnMut(&[u8]) -> bool + 'static, Q: FnOnce(Result<(Vec<u8>, Option<GString>), Error>) + 'static>( &self, cancellable: Option<&impl IsA<Cancellable>>, read_more_callback: P, callback: Q )

Reads the partial contents of a file. A GFileReadMoreCallback should be used to stop reading from the file when appropriate, else this function will behave exactly as FileExt::load_contents_async(). This operation can be finished by g_file_load_partial_contents_finish().

Users of this function should be aware that user_data is passed to both the read_more_callback and the callback.

If cancellable is not None, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error IOErrorEnum::Cancelled will be returned.

cancellable

optional Cancellable object, None to ignore

read_more_callback

a GFileReadMoreCallback to receive partial data and to specify whether further data should be read

callback

a GAsyncReadyCallback to call when the request is satisfied

fn measure_disk_usage( &self, flags: FileMeasureFlags, cancellable: Option<&impl IsA<Cancellable>>, progress_callback: Option<Box<dyn FnMut(bool, u64, u64, u64) + 'static>> ) -> Result<(u64, u64, u64), Error>

Recursively measures the disk usage of self.

This is essentially an analog of the ‘du’ command, but it also reports the number of directories and non-directory files encountered (including things like symbolic links).

By default, errors are only reported against the toplevel file itself. Errors found while recursing are silently ignored, unless FileMeasureFlags::REPORT_ANY_ERROR is given in flags.

The returned size, disk_usage, is in bytes and should be formatted with g_format_size() in order to get something reasonable for showing in a user interface.

progress_callback and progress_data can be given to request periodic progress updates while scanning. See the documentation for GFileMeasureProgressCallback for information about when and how the callback will be invoked.

flags

FileMeasureFlags

cancellable

optional Cancellable

progress_callback

a GFileMeasureProgressCallback

progress_data

user_data for progress_callback

Returns

true if successful, with the out parameters set. false otherwise, with error set.

disk_usage

the number of bytes of disk space used

num_dirs

the number of directories encountered

num_files

the number of non-directories encountered

fn measure_disk_usage_async<P: FnOnce(Result<(u64, u64, u64), Error>) + 'static>( &self, flags: FileMeasureFlags, io_priority: Priority, cancellable: Option<&impl IsA<Cancellable>>, progress_callback: Option<Box<dyn FnMut(bool, u64, u64, u64) + 'static>>, callback: P )

Recursively measures the disk usage of self.

This is the asynchronous version of FileExtManual::measure_disk_usage(). See there for more information.

flags

FileMeasureFlags

io_priority

the [I/O priority][io-priority] of the request

cancellable

optional Cancellable

progress_callback

a GFileMeasureProgressCallback

progress_data

user_data for progress_callback

callback

a GAsyncReadyCallback to call when complete

fn measure_disk_usage_future( &self, flags: FileMeasureFlags, io_priority: Priority ) -> (Pin<Box<dyn Future<Output = Result<(u64, u64, u64), Error>> + 'static>>, Pin<Box<dyn Stream<Item = (bool, u64, u64, u64)> + 'static>>)

fn move_async<Q: FnOnce(Result<(), Error>) + 'static>( &self, destination: &impl IsA<File>, flags: FileCopyFlags, io_priority: Priority, cancellable: Option<&impl IsA<Cancellable>>, progress_callback: Option<Box<dyn FnMut(i64, i64)>>, callback: Q )

Available on crate feature v2_72 only.

Asynchronously moves a file self to the location of destination. For details of the behaviour, see FileExt::move_().

If progress_callback is not None, then that function that will be called just like in FileExt::move_(). The callback will run in the default main context of the thread calling FileExtManual::move_async() — the same context as callback is run in.

When the operation is finished, callback will be called. You can then call g_file_move_finish() to get the result of the operation.

destination

File pointing to the destination location

flags

set of FileCopyFlags

io_priority

the [I/O priority][io-priority] of the request

cancellable

optional Cancellable object, None to ignore

progress_callback

GFileProgressCallback function for updates

progress_callback_data

gpointer to user data for the callback function

callback

a GAsyncReadyCallback to call when the request is satisfied

fn move_future( &self, destination: &impl IsA<File> + Clone + 'static, flags: FileCopyFlags, io_priority: Priority ) -> (Pin<Box<dyn Future<Output = Result<(), Error>> + 'static>>, Pin<Box<dyn Stream<Item = (i64, i64)> + 'static>>)

Available on crate feature v2_72 only.

Implementors

impl<O: IsA<File>> FileExtManual for O