[−][src]Trait gio::FileExt
Required methods
fn append_to<P: IsA<Cancellable>>(
&self,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileOutputStream, Error>
&self,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileOutputStream, Error>
Gets an output stream for appending data to the file. If the file doesn't already exist it is created.
By default files created are generally readable by everyone,
but if you pass FileCreateFlags::Private in flags the file
will be made readable only to the current user, to the level that
is supported on the target filesystem.
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.
Some file systems don't allow all file names, and may return an
IOErrorEnum::InvalidFilename error. If the file is a directory the
IOErrorEnum::IsDirectory error will be returned. Other errors are
possible too, and depend on what kind of filesystem the file is on.
flags
a set of FileCreateFlags
cancellable
optional Cancellable object,
None to ignore
Returns
a FileOutputStream, or None on error.
Free the returned object with gobject::ObjectExt::unref.
fn append_to_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileOutputStream, Error>) + Send + 'static>(
&self,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
&self,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
Asynchronously opens self for appending.
For more details, see File::append_to which is
the synchronous version of this call.
When the operation is finished, callback will be called.
You can then call File::append_to_finish to get the result
of the operation.
flags
a set of FileCreateFlags
io_priority
the [I/O priority][io-priority] of the request
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback to call
when the request is satisfied
user_data
the data to pass to callback function
fn append_to_async_future(
&self,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileOutputStream, Error>> + 'static>>
&self,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileOutputStream, Error>> + 'static>>
fn copy<P: IsA<File>, Q: IsA<Cancellable>>(
&self,
destination: &P,
flags: FileCopyFlags,
cancellable: Option<&Q>,
progress_callback: Option<&mut dyn FnMut(i64, i64)>
) -> Result<(), Error>
&self,
destination: &P,
flags: FileCopyFlags,
cancellable: Option<&Q>,
progress_callback: Option<&mut dyn FnMut(i64, i64)>
) -> Result<(), Error>
Copies the file self to the location specified by destination.
Can not handle recursive copies of directories.
If the flag FileCopyFlags::Overwrite is specified an already
existing destination file is overwritten.
If the flag FileCopyFlags::NofollowSymlinks is specified then symlinks
will be copied as symlinks, otherwise the target of the
self symlink will be copied.
If the flag FileCopyFlags::AllMetadata is specified then all the metadata
that is possible to copy is copied, not just the default subset (which,
for instance, does not include the owner, see FileInfo).
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 progress_callback is not None, then the operation can be monitored
by setting this to a GFileProgressCallback function.
progress_callback_data will be passed to this function. It is guaranteed
that this callback will be called after all data has been transferred with
the total number of bytes copied during the operation.
If the self file does not exist, then the IOErrorEnum::NotFound error
is returned, independent on the status of the destination.
If FileCopyFlags::Overwrite is not specified and the target exists, then
the error IOErrorEnum::Exists is returned.
If trying to overwrite a file over a directory, the IOErrorEnum::IsDirectory
error is returned. If trying to overwrite a directory with a directory the
IOErrorEnum::WouldMerge error is returned.
If the source is a directory and the target does not exist, or
FileCopyFlags::Overwrite is specified and the target is a file, then the
IOErrorEnum::WouldRecurse error is returned.
If you are interested in copying the File object itself (not the on-disk
file), see File::dup.
destination
destination File
flags
set of FileCopyFlags
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
Returns
true on success, false otherwise.
fn copy_attributes<P: IsA<File>, Q: IsA<Cancellable>>(
&self,
destination: &P,
flags: FileCopyFlags,
cancellable: Option<&Q>
) -> Result<(), Error>
&self,
destination: &P,
flags: FileCopyFlags,
cancellable: Option<&Q>
) -> Result<(), Error>
Copies the file attributes from self to destination.
Normally only a subset of the file attributes are copied,
those that are copies in a normal file copy operation
(which for instance does not include e.g. owner). However
if FileCopyFlags::AllMetadata is specified in flags, then
all the metadata that is possible to copy is copied. This
is useful when implementing move by copy + delete source.
destination
a File to copy attributes to
flags
a set of FileCopyFlags
cancellable
optional Cancellable object,
None to ignore
Returns
true if the attributes were copied successfully,
false otherwise.
fn create<P: IsA<Cancellable>>(
&self,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileOutputStream, Error>
&self,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileOutputStream, Error>
Creates a new file and returns an output stream for writing to it. The file must not already exist.
By default files created are generally readable by everyone,
but if you pass FileCreateFlags::Private in flags the file
will be made readable only to the current user, to the level
that is supported on the target filesystem.
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 a file or directory with this name already exists the
IOErrorEnum::Exists error will be returned. Some file systems don't
allow all file names, and may return an IOErrorEnum::InvalidFilename
error, and if the name is to long IOErrorEnum::FilenameTooLong will
be returned. Other errors are possible too, and depend on what kind
of filesystem the file is on.
flags
a set of FileCreateFlags
cancellable
optional Cancellable object,
None to ignore
Returns
a FileOutputStream for the newly created
file, or None on error.
Free the returned object with gobject::ObjectExt::unref.
fn create_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileOutputStream, Error>) + Send + 'static>(
&self,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
&self,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
Asynchronously creates a new file and returns an output stream for writing to it. The file must not already exist.
For more details, see File::create which is
the synchronous version of this call.
When the operation is finished, callback will be called.
You can then call File::create_finish to get the result
of the operation.
flags
a set of FileCreateFlags
io_priority
the [I/O priority][io-priority] of the request
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback to call
when the request is satisfied
user_data
the data to pass to callback function
fn create_async_future(
&self,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileOutputStream, Error>> + 'static>>
&self,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileOutputStream, Error>> + 'static>>
fn create_readwrite<P: IsA<Cancellable>>(
&self,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileIOStream, Error>
&self,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileIOStream, Error>
Creates a new file and returns a stream for reading and writing to it. The file must not already exist.
By default files created are generally readable by everyone,
but if you pass FileCreateFlags::Private in flags the file
will be made readable only to the current user, to the level
that is supported on the target filesystem.
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 a file or directory with this name already exists, the
IOErrorEnum::Exists error will be returned. Some file systems don't
allow all file names, and may return an IOErrorEnum::InvalidFilename
error, and if the name is too long, IOErrorEnum::FilenameTooLong
will be returned. Other errors are possible too, and depend on what
kind of filesystem the file is on.
Note that in many non-local file cases read and write streams are not supported, so make sure you really need to do read and write streaming, rather than just opening for reading or writing.
flags
a set of FileCreateFlags
cancellable
optional Cancellable object,
None to ignore
Returns
a FileIOStream for the newly created
file, or None on error.
Free the returned object with gobject::ObjectExt::unref.
fn create_readwrite_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileIOStream, Error>) + Send + 'static>(
&self,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
&self,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
Asynchronously creates a new file and returns a stream for reading and writing to it. The file must not already exist.
For more details, see File::create_readwrite which is
the synchronous version of this call.
When the operation is finished, callback will be called.
You can then call File::create_readwrite_finish to get
the result of the operation.
flags
a set of FileCreateFlags
io_priority
the [I/O priority][io-priority] of the request
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback to call
when the request is satisfied
user_data
the data to pass to callback function
fn create_readwrite_async_future(
&self,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileIOStream, Error>> + 'static>>
&self,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileIOStream, Error>> + 'static>>
fn delete<P: IsA<Cancellable>>(
&self,
cancellable: Option<&P>
) -> Result<(), Error>
&self,
cancellable: Option<&P>
) -> Result<(), Error>
Deletes a file. If the self is a directory, it will only be
deleted if it is empty. This has the same semantics as g_unlink.
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
Returns
true if the file was deleted. false otherwise.
fn delete_async<P: IsA<Cancellable>, Q: FnOnce(Result<(), Error>) + Send + 'static>(
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
Asynchronously delete a file. If the self is a directory, it will
only be deleted if it is empty. This has the same semantics as
g_unlink.
io_priority
the [I/O priority][io-priority] of the request
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback to call
when the request is satisfied
user_data
the data to pass to callback function
fn delete_async_future(
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
fn dup(&self) -> Option<File>
Duplicates a File handle. This operation does not duplicate
the actual file or directory represented by the File; see
File::copy if attempting to copy a file.
File::dup is useful when a second handle is needed to the same underlying
file, for use in a separate thread (File is not thread-safe). For use
within the same thread, use gobject::ObjectExt::ref to increment the existing object’s
reference count.
This call does no blocking I/O.
Returns
a new File that is a duplicate
of the given File.
fn eject_mountable_with_operation<P: IsA<MountOperation>, Q: IsA<Cancellable>, R: FnOnce(Result<(), Error>) + Send + 'static>(
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)
Starts an asynchronous eject on a mountable.
When this operation has completed, callback will be called with
user_user data, and the operation can be finalized with
File::eject_mountable_with_operation_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.
flags
flags affecting the operation
mount_operation
a MountOperation,
or None to avoid user interaction
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback to call
when the request is satisfied, or None
user_data
the data to pass to callback function
fn eject_mountable_with_operation_future<P: IsA<MountOperation> + Clone + 'static>(
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
fn enumerate_children<P: IsA<Cancellable>>(
&self,
attributes: &str,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<FileEnumerator, Error>
&self,
attributes: &str,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<FileEnumerator, Error>
Gets the requested information about the files in a directory.
The result is a FileEnumerator object that will give out
FileInfo objects for all the files in the directory.
The attributes value is a string that specifies the file
attributes that should be gathered. It is not an error if
it's not possible to read a particular requested attribute
from a file - it just won't be set. attributes should
be a comma-separated list of attributes or attribute wildcards.
The wildcard "" means all attributes, and a wildcard like
"standard::" means all attributes in the standard namespace.
An example attribute query be "standard::*,owner::user".
The standard attributes are available as defines, like
G_FILE_ATTRIBUTE_STANDARD_NAME.
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 the file does not exist, the IOErrorEnum::NotFound error will
be returned. If the file is not a directory, the IOErrorEnum::NotDirectory
error will be returned. Other errors are possible too.
attributes
an attribute query string
flags
a set of FileQueryInfoFlags
cancellable
optional Cancellable object,
None to ignore
Returns
A FileEnumerator if successful,
None on error. Free the returned object with gobject::ObjectExt::unref.
fn equal<P: IsA<File>>(&self, file2: &P) -> bool
Checks if the two given GFiles refer to the same file.
Note that two GFiles that differ can still refer to the same
file on the filesystem due to various forms of filename
aliasing.
This call does no blocking I/O.
file2
the second File
Returns
true if self and file2 are equal.
fn find_enclosing_mount<P: IsA<Cancellable>>(
&self,
cancellable: Option<&P>
) -> Result<Mount, Error>
&self,
cancellable: Option<&P>
) -> Result<Mount, Error>
Gets a Mount for the File.
Mount is returned only for user interesting locations, see
VolumeMonitor. If the FileIface for self does not have a mount,
error will be set to IOErrorEnum::NotFound and None will be returned.
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
Returns
a Mount where the self is located
or None on error.
Free the returned object with gobject::ObjectExt::unref.
fn get_basename(&self) -> Option<PathBuf>
Gets the base name (the last component of the path) for a given File.
If called for the top level of a system (such as the filesystem root or a uri like sftp://host/) it will return a single directory separator (and on Windows, possibly a drive letter).
The base name is a byte string (not UTF-8). It has no defined encoding
or rules other than it may not contain zero bytes. If you want to use
filenames in a user interface you should use the display name that you
can get by requesting the G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME
attribute with File::query_info.
This call does no blocking I/O.
Returns
string containing the File's
base name, or None if given File is invalid. The returned string
should be freed with g_free when no longer needed.
fn get_child<P: AsRef<Path>>(&self, name: P) -> Option<File>
Gets a child of self with basename equal to name.
Note that the file with that specific name might not exist, but
you can still have a File that points to it. You can use this
for instance to create that file.
This call does no blocking I/O.
name
string containing the child's basename
Returns
a File to a child specified by name.
Free the returned object with gobject::ObjectExt::unref.
fn get_child_for_display_name(&self, display_name: &str) -> Result<File, Error>
Gets the child of self for a given display_name (i.e. a UTF-8
version of the name). If this function fails, it returns None
and error will be set. This is very useful when constructing a
File for a new file and the user entered the filename in the
user interface, for instance when you select a directory and
type a filename in the file selector.
This call does no blocking I/O.
display_name
string to a possible child
Returns
a File to the specified child, or
None if the display name couldn't be converted.
Free the returned object with gobject::ObjectExt::unref.
fn get_parent(&self) -> Option<File>
Gets the parent directory for the self.
If the self represents the root directory of the
file system, then None will be returned.
This call does no blocking I/O.
Returns
a File structure to the
parent of the given File or None if there is no parent. Free
the returned object with gobject::ObjectExt::unref.
fn get_parse_name(&self) -> Option<GString>
Gets the parse name of the self.
A parse name is a UTF-8 string that describes the
file such that one can get the File back using
File::parse_name.
This is generally used to show the File as a nice
full-pathname kind of string in a user interface,
like in a location entry.
For local files with names that can safely be converted to UTF-8 the pathname is used, otherwise the IRI is used (a form of URI that allows UTF-8 characters unescaped).
This call does no blocking I/O.
Returns
a string containing the File's parse name.
The returned string should be freed with g_free
when no longer needed.
fn get_path(&self) -> Option<PathBuf>
Gets the local pathname for File, if one exists. If non-None, this is
guaranteed to be an absolute, canonical path. It might contain symlinks.
This call does no blocking I/O.
Returns
string containing the File's path,
or None if no such path exists. The returned string should be freed
with g_free when no longer needed.
fn get_relative_path<P: IsA<File>>(&self, descendant: &P) -> Option<PathBuf>
Gets the path for descendant relative to self.
This call does no blocking I/O.
descendant
input File
Returns
string with the relative path from
descendant to self, or None if descendant doesn't have self as
prefix. The returned string should be freed with g_free when
no longer needed.
fn get_uri(&self) -> GString
Gets the URI for the self.
This call does no blocking I/O.
Returns
a string containing the File's URI.
The returned string should be freed with g_free
when no longer needed.
fn get_uri_scheme(&self) -> GString
Gets the URI scheme for a File.
RFC 3986 decodes the scheme as:
URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
Common schemes include "file", "http", "ftp", etc.
This call does no blocking I/O.
Returns
a string containing the URI scheme for the given
File. The returned string should be freed with g_free
when no longer needed.
fn has_parent<P: IsA<File>>(&self, parent: Option<&P>) -> bool
Checks if self has a parent, and optionally, if it is parent.
If parent is None then this function returns true if self has any
parent at all. If parent is non-None then true is only returned
if self is an immediate child of parent.
parent
the parent to check for, or None
Returns
true if self is an immediate child of parent (or any parent in
the case that parent is None).
fn has_prefix<P: IsA<File>>(&self, prefix: &P) -> bool
Checks whether self has the prefix specified by prefix.
In other words, if the names of initial elements of self's
pathname match prefix. Only full pathname elements are matched,
so a path like /foo is not considered a prefix of /foobar, only
of /foo/bar.
A File is not a prefix of itself. If you want to check for
equality, use File::equal.
This call does no I/O, as it works purely on names. As such it can
sometimes return false even if self is inside a prefix (from a
filesystem point of view), because the prefix of self is an alias
of prefix.
prefix
input File
Returns
true if the files's parent, grandparent, etc is prefix,
false otherwise.
fn has_uri_scheme(&self, uri_scheme: &str) -> bool
Checks to see if a File has a given URI scheme.
This call does no blocking I/O.
uri_scheme
a string containing a URI scheme
Returns
true if File's backend supports the
given URI scheme, false if URI scheme is None,
not supported, or File is invalid.
fn is_native(&self) -> bool
Checks to see if a file is native to the platform.
A native file is one expressed in the platform-native filename format, e.g. "C:\Windows" or "/usr/bin/". This does not mean the file is local, as it might be on a locally mounted remote filesystem.
On some systems non-native files may be available using the native
filesystem via a userspace filesystem (FUSE), in these cases this call
will return false, but File::get_path will still return a native path.
This call does no blocking I/O.
Returns
true if self is native
fn load_contents<P: IsA<Cancellable>>(
&self,
cancellable: Option<&P>
) -> Result<(Vec<u8>, GString), Error>
&self,
cancellable: Option<&P>
) -> Result<(Vec<u8>, GString), Error>
Loads the content of the file into memory. The data is always
zero-terminated, but this is not included in the resultant length.
The returned content should be freed with g_free when no longer
needed.
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
contents
a location to place the contents of the file
length
a location to place the length of the contents of the file,
or None if the length is not needed
etag_out
a location to place the current entity tag for the file,
or None if the entity tag is not needed
Returns
true if the self's contents were successfully loaded.
false if there were errors.
fn load_contents_async<P: IsA<Cancellable>, Q: FnOnce(Result<(Vec<u8>, GString), Error>) + Send + 'static>(
&self,
cancellable: Option<&P>,
callback: Q
)
&self,
cancellable: Option<&P>,
callback: Q
)
Starts an asynchronous load of the self's contents.
For more details, see File::load_contents which is
the synchronous version of this call.
When the load operation has completed, callback will be called
with user data. To finish the operation, call
File::load_contents_finish with the AsyncResult returned by
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
callback
a GAsyncReadyCallback to call when the request is satisfied
user_data
the data to pass to callback function
fn load_contents_async_future(
&self
) -> Pin<Box_<dyn Future<Output = Result<(Vec<u8>, GString), Error>> + 'static>>
&self
) -> Pin<Box_<dyn Future<Output = Result<(Vec<u8>, GString), Error>> + 'static>>
fn make_directory<P: IsA<Cancellable>>(
&self,
cancellable: Option<&P>
) -> Result<(), Error>
&self,
cancellable: Option<&P>
) -> Result<(), Error>
Creates a directory. Note that this will only create a child directory
of the immediate parent directory of the path or URI given by the File.
To recursively create directories, see File::make_directory_with_parents.
This function will fail if the parent directory does not exist, setting
error to IOErrorEnum::NotFound. If the file system doesn't support
creating directories, this function will fail, setting error to
IOErrorEnum::NotSupported.
For a local File the newly created directory will have the default
(current) ownership and permissions of the current process.
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
Returns
true on successful creation, false otherwise.
fn make_directory_async<P: IsA<Cancellable>, Q: FnOnce(Result<(), Error>) + Send + 'static>(
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
Asynchronously creates a directory.
io_priority
the [I/O priority][io-priority] of the request
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback to call
when the request is satisfied
user_data
the data to pass to callback function
fn make_directory_async_future(
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
fn make_directory_with_parents<P: IsA<Cancellable>>(
&self,
cancellable: Option<&P>
) -> Result<(), Error>
&self,
cancellable: Option<&P>
) -> Result<(), Error>
Creates a directory and any parent directories that may not
exist similar to 'mkdir -p'. If the file system does not support
creating directories, this function will fail, setting error to
IOErrorEnum::NotSupported. If the directory itself already exists,
this function will fail setting error to IOErrorEnum::Exists, unlike
the similar g_mkdir_with_parents.
For a local File the newly created directories will have the default
(current) ownership and permissions of the current process.
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
Returns
true if all directories have been successfully created, false
otherwise.
fn make_symbolic_link<P: AsRef<Path>, Q: IsA<Cancellable>>(
&self,
symlink_value: P,
cancellable: Option<&Q>
) -> Result<(), Error>
&self,
symlink_value: P,
cancellable: Option<&Q>
) -> Result<(), Error>
Creates a symbolic link named self which contains the string
symlink_value.
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.
symlink_value
a string with the path for the target of the new symlink
cancellable
optional Cancellable object,
None to ignore
Returns
true on the creation of a new symlink, false otherwise.
fn measure_disk_usage<P: IsA<Cancellable>>(
&self,
flags: FileMeasureFlags,
cancellable: Option<&P>,
progress_callback: Option<Box_<dyn Fn(bool, u64, u64, u64) + 'static>>
) -> Result<(u64, u64, u64), Error>
&self,
flags: FileMeasureFlags,
cancellable: Option<&P>,
progress_callback: Option<Box_<dyn Fn(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::ReportAnyError 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
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
Returns
true if successful, with the out parameters set.
false otherwise, with error set.
fn monitor<P: IsA<Cancellable>>(
&self,
flags: FileMonitorFlags,
cancellable: Option<&P>
) -> Result<FileMonitor, Error>
&self,
flags: FileMonitorFlags,
cancellable: Option<&P>
) -> Result<FileMonitor, Error>
Obtains a file or directory monitor for the given file, depending on the type of the file.
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.
flags
a set of FileMonitorFlags
cancellable
optional Cancellable object,
None to ignore
Returns
a FileMonitor for the given self,
or None on error.
Free the returned object with gobject::ObjectExt::unref.
fn monitor_directory<P: IsA<Cancellable>>(
&self,
flags: FileMonitorFlags,
cancellable: Option<&P>
) -> Result<FileMonitor, Error>
&self,
flags: FileMonitorFlags,
cancellable: Option<&P>
) -> Result<FileMonitor, Error>
Obtains a directory monitor for the given file. This may fail if directory monitoring is not supported.
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.
It does not make sense for flags to contain
FileMonitorFlags::WatchHardLinks, since hard links can not be made to
directories. It is not possible to monitor all the files in a
directory for changes made via hard links; if you want to do this then
you must register individual watches with File::monitor.
flags
a set of FileMonitorFlags
cancellable
optional Cancellable object,
None to ignore
Returns
a FileMonitor for the given self,
or None on error.
Free the returned object with gobject::ObjectExt::unref.
fn monitor_file<P: IsA<Cancellable>>(
&self,
flags: FileMonitorFlags,
cancellable: Option<&P>
) -> Result<FileMonitor, Error>
&self,
flags: FileMonitorFlags,
cancellable: Option<&P>
) -> Result<FileMonitor, Error>
Obtains a file monitor for the given file. If no file notification mechanism exists, then regular polling of the file is used.
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 flags contains FileMonitorFlags::WatchHardLinks then the monitor
will also attempt to report changes made to the file via another
filename (ie, a hard link). Without this flag, you can only rely on
changes made through the filename contained in self to be
reported. Using this flag may result in an increase in resource
usage, and may not have any effect depending on the FileMonitor
backend and/or filesystem type.
flags
a set of FileMonitorFlags
cancellable
optional Cancellable object,
None to ignore
Returns
a FileMonitor for the given self,
or None on error.
Free the returned object with gobject::ObjectExt::unref.
fn mount_enclosing_volume<P: IsA<MountOperation>, Q: IsA<Cancellable>, R: FnOnce(Result<(), Error>) + Send + 'static>(
&self,
flags: MountMountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)
&self,
flags: MountMountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)
Starts a mount_operation, mounting the volume that contains
the file self.
When this operation has completed, callback will be called with
user_user data, and the operation can be finalized with
File::mount_enclosing_volume_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.
flags
flags affecting the operation
mount_operation
a MountOperation
or None to avoid user interaction
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback to call
when the request is satisfied, or None
user_data
the data to pass to callback function
fn mount_enclosing_volume_future<P: IsA<MountOperation> + Clone + 'static>(
&self,
flags: MountMountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
&self,
flags: MountMountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
fn mount_mountable<P: IsA<MountOperation>, Q: IsA<Cancellable>, R: FnOnce(Result<File, Error>) + Send + 'static>(
&self,
flags: MountMountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)
&self,
flags: MountMountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)
Mounts a file of type G_FILE_TYPE_MOUNTABLE.
Using mount_operation, you can request callbacks when, for instance,
passwords are needed during authentication.
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.
When the operation is finished, callback will be called.
You can then call File::mount_mountable_finish to get
the result of the operation.
flags
flags affecting the operation
mount_operation
a MountOperation,
or None to avoid user interaction
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback to call
when the request is satisfied, or None
user_data
the data to pass to callback function
fn mount_mountable_future<P: IsA<MountOperation> + Clone + 'static>(
&self,
flags: MountMountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<File, Error>> + 'static>>
&self,
flags: MountMountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<File, Error>> + 'static>>
fn move_<P: IsA<File>, Q: IsA<Cancellable>>(
&self,
destination: &P,
flags: FileCopyFlags,
cancellable: Option<&Q>,
progress_callback: Option<&mut dyn FnMut(i64, i64)>
) -> Result<(), Error>
&self,
destination: &P,
flags: FileCopyFlags,
cancellable: Option<&Q>,
progress_callback: Option<&mut dyn FnMut(i64, i64)>
) -> Result<(), Error>
fn open_readwrite<P: IsA<Cancellable>>(
&self,
cancellable: Option<&P>
) -> Result<FileIOStream, Error>
&self,
cancellable: Option<&P>
) -> Result<FileIOStream, Error>
Opens an existing file for reading and writing. The result is
a FileIOStream that can be used to read and write the contents
of the file.
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 the file does not exist, the IOErrorEnum::NotFound error will
be returned. If the file is a directory, the IOErrorEnum::IsDirectory
error will be returned. Other errors are possible too, and depend on
what kind of filesystem the file is on. Note that in many non-local
file cases read and write streams are not supported, so make sure you
really need to do read and write streaming, rather than just opening
for reading or writing.
cancellable
a Cancellable
Returns
FileIOStream or None on error.
Free the returned object with gobject::ObjectExt::unref.
fn open_readwrite_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileIOStream, Error>) + Send + 'static>(
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
Asynchronously opens self for reading and writing.
For more details, see File::open_readwrite which is
the synchronous version of this call.
When the operation is finished, callback will be called.
You can then call File::open_readwrite_finish to get
the result of the operation.
io_priority
the [I/O priority][io-priority] of the request
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback to call
when the request is satisfied
user_data
the data to pass to callback function
fn open_readwrite_async_future(
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileIOStream, Error>> + 'static>>
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileIOStream, Error>> + 'static>>
fn poll_mountable<P: IsA<Cancellable>, Q: FnOnce(Result<(), Error>) + Send + 'static>(
&self,
cancellable: Option<&P>,
callback: Q
)
&self,
cancellable: Option<&P>,
callback: Q
)
Polls a file of type FileType::Mountable.
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.
When the operation is finished, callback will be called.
You can then call File::mount_mountable_finish to get
the result of the operation.
cancellable
optional Cancellable object, None to ignore
callback
a GAsyncReadyCallback to call
when the request is satisfied, or None
user_data
the data to pass to callback function
fn poll_mountable_future(
&self
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
&self
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
fn query_default_handler<P: IsA<Cancellable>>(
&self,
cancellable: Option<&P>
) -> Result<AppInfo, Error>
&self,
cancellable: Option<&P>
) -> Result<AppInfo, Error>
Returns the AppInfo that is registered as the default
application to handle the file specified by self.
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
Returns
a AppInfo if the handle was found,
None if there were errors.
When you are done with it, release it with gobject::ObjectExt::unref
fn query_exists<P: IsA<Cancellable>>(&self, cancellable: Option<&P>) -> bool
Utility function to check if a particular file exists. This is
implemented using File::query_info and as such does blocking I/O.
Note that in many cases it is racy to first check for file existence and then execute something based on the outcome of that, because the file might have been created or removed in between the operations. The general approach to handling that is to not check, but just do the operation and handle the errors as they come.
As an example of race-free checking, take the case of reading a file,
and if it doesn't exist, creating it. There are two racy versions: read
it, and on error create it; and: check if it exists, if not create it.
These can both result in two processes creating the file (with perhaps
a partially written file as the result). The correct approach is to
always try to create the file with File::create which will either
atomically create the file or fail with a IOErrorEnum::Exists error.
However, in many cases an existence check is useful in a user interface, for instance to make a menu item sensitive/insensitive, so that you don't have to fool users that something is possible and then just show an error dialog. If you do this, you should make sure to also handle the errors that can happen due to races when you execute the operation.
cancellable
optional Cancellable object,
None to ignore
Returns
true if the file exists (and can be detected without error),
false otherwise (or if cancelled).
fn query_file_type<P: IsA<Cancellable>>(
&self,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> FileType
&self,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> FileType
Utility function to inspect the FileType of a file. This is
implemented using File::query_info and as such does blocking I/O.
The primary use case of this method is to check if a file is a regular file, directory, or symlink.
flags
a set of FileQueryInfoFlags passed to File::query_info
cancellable
optional Cancellable object,
None to ignore
Returns
The FileType of the file and FileType::Unknown
if the file does not exist
fn query_filesystem_info<P: IsA<Cancellable>>(
&self,
attributes: &str,
cancellable: Option<&P>
) -> Result<FileInfo, Error>
&self,
attributes: &str,
cancellable: Option<&P>
) -> Result<FileInfo, Error>
Similar to File::query_info, but obtains information
about the filesystem the self is on, rather than the file itself.
For instance the amount of space available and the type of
the filesystem.
The attributes value is a string that specifies the attributes
that should be gathered. It is not an error if it's not possible
to read a particular requested attribute from a file - it just
won't be set. attributes should be a comma-separated list of
attributes or attribute wildcards. The wildcard "" means all
attributes, and a wildcard like "filesystem::" means all attributes
in the filesystem namespace. The standard namespace for filesystem
attributes is "filesystem". Common attributes of interest are
G_FILE_ATTRIBUTE_FILESYSTEM_SIZE (the total size of the filesystem
in bytes), G_FILE_ATTRIBUTE_FILESYSTEM_FREE (number of bytes available),
and G_FILE_ATTRIBUTE_FILESYSTEM_TYPE (type of the filesystem).
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 the file does not exist, the IOErrorEnum::NotFound error will
be returned. Other errors are possible too, and depend on what
kind of filesystem the file is on.
attributes
an attribute query string
cancellable
optional Cancellable object,
None to ignore
Returns
a FileInfo or None if there was an error.
Free the returned object with gobject::ObjectExt::unref.
fn query_filesystem_info_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileInfo, Error>) + Send + 'static>(
&self,
attributes: &str,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
&self,
attributes: &str,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
Asynchronously gets the requested information about the filesystem
that the specified self is on. The result is a FileInfo object
that contains key-value attributes (such as type or size for the
file).
For more details, see File::query_filesystem_info which is the
synchronous version of this call.
When the operation is finished, callback will be called. You can
then call File::query_info_finish to get the result of the
operation.
attributes
an attribute query string
io_priority
the [I/O priority][io-priority] of the request
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback to call
when the request is satisfied
user_data
the data to pass to callback function
fn query_filesystem_info_async_future(
&self,
attributes: &str,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileInfo, Error>> + 'static>>
&self,
attributes: &str,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileInfo, Error>> + 'static>>
fn query_info<P: IsA<Cancellable>>(
&self,
attributes: &str,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<FileInfo, Error>
&self,
attributes: &str,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<FileInfo, Error>
Gets the requested information about specified self.
The result is a FileInfo object that contains key-value
attributes (such as the type or size of the file).
The attributes value is a string that specifies the file
attributes that should be gathered. It is not an error if
it's not possible to read a particular requested attribute
from a file - it just won't be set. attributes should be a
comma-separated list of attributes or attribute wildcards.
The wildcard "" means all attributes, and a wildcard like
"standard::" means all attributes in the standard namespace.
An example attribute query be "standard::*,owner::user".
The standard attributes are available as defines, like
G_FILE_ATTRIBUTE_STANDARD_NAME.
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.
For symlinks, normally the information about the target of the
symlink is returned, rather than information about the symlink
itself. However if you pass FileQueryInfoFlags::NofollowSymlinks
in flags the information about the symlink itself will be returned.
Also, for symlinks that point to non-existing files the information
about the symlink itself will be returned.
If the file does not exist, the IOErrorEnum::NotFound error will be
returned. Other errors are possible too, and depend on what kind of
filesystem the file is on.
attributes
an attribute query string
flags
a set of FileQueryInfoFlags
cancellable
optional Cancellable object,
None to ignore
Returns
a FileInfo for the given self, or None
on error. Free the returned object with gobject::ObjectExt::unref.
fn query_info_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileInfo, Error>) + Send + 'static>(
&self,
attributes: &str,
flags: FileQueryInfoFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
&self,
attributes: &str,
flags: FileQueryInfoFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
Asynchronously gets the requested information about specified self.
The result is a FileInfo object that contains key-value attributes
(such as type or size for the file).
For more details, see File::query_info which is the synchronous
version of this call.
When the operation is finished, callback will be called. You can
then call File::query_info_finish to get the result of the operation.
attributes
an attribute query string
flags
a set of FileQueryInfoFlags
io_priority
the [I/O priority][io-priority] of the request
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback to call when the
request is satisfied
user_data
the data to pass to callback function
fn query_info_async_future(
&self,
attributes: &str,
flags: FileQueryInfoFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileInfo, Error>> + 'static>>
&self,
attributes: &str,
flags: FileQueryInfoFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileInfo, Error>> + 'static>>
fn read<P: IsA<Cancellable>>(
&self,
cancellable: Option<&P>
) -> Result<FileInputStream, Error>
&self,
cancellable: Option<&P>
) -> Result<FileInputStream, Error>
Opens a file for reading. The result is a FileInputStream that
can be used to read the contents of the file.
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 the file does not exist, the IOErrorEnum::NotFound error will be
returned. If the file is a directory, the IOErrorEnum::IsDirectory
error will be returned. Other errors are possible too, and depend
on what kind of filesystem the file is on.
cancellable
a Cancellable
Returns
FileInputStream or None on error.
Free the returned object with gobject::ObjectExt::unref.
fn read_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileInputStream, Error>) + Send + 'static>(
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
Asynchronously opens self for reading.
For more details, see File::read which is
the synchronous version of this call.
When the operation is finished, callback will be called.
You can then call File::read_finish to get the result
of the operation.
io_priority
the [I/O priority][io-priority] of the request
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback to call
when the request is satisfied
user_data
the data to pass to callback function
fn read_async_future(
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileInputStream, Error>> + 'static>>
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileInputStream, Error>> + 'static>>
fn replace<P: IsA<Cancellable>>(
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileOutputStream, Error>
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileOutputStream, Error>
Returns an output stream for overwriting the file, possibly creating a backup copy of the file first. If the file doesn't exist, it will be created.
This will try to replace the file in the safest way possible so that any errors during the writing will not affect an already existing copy of the file. For instance, for local files it may write to a temporary file and then atomically rename over the destination when the stream is closed.
By default files created are generally readable by everyone,
but if you pass FileCreateFlags::Private in flags the file
will be made readable only to the current user, to the level that
is supported on the target filesystem.
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 you pass in a non-None etag value and self already exists, then
this value is compared to the current entity tag of the file, and if
they differ an IOErrorEnum::WrongEtag error is returned. This
generally means that the file has been changed since you last read
it. You can get the new etag from FileOutputStreamExt::get_etag
after you've finished writing and closed the FileOutputStream. When
you load a new file you can use FileInputStreamExt::query_info to
get the etag of the file.
If make_backup is true, this function will attempt to make a
backup of the current file before overwriting it. If this fails
a IOErrorEnum::CantCreateBackup error will be returned. If you
want to replace anyway, try again with make_backup set to false.
If the file is a directory the IOErrorEnum::IsDirectory error will
be returned, and if the file is some other form of non-regular file
then a IOErrorEnum::NotRegularFile error will be returned. Some
file systems don't allow all file names, and may return an
IOErrorEnum::InvalidFilename error, and if the name is to long
IOErrorEnum::FilenameTooLong will be returned. Other errors are
possible too, and depend on what kind of filesystem the file is on.
etag
an optional [entity tag][gfile-etag]
for the current File, or None to ignore
make_backup
true if a backup should be created
flags
a set of FileCreateFlags
cancellable
optional Cancellable object,
None to ignore
Returns
a FileOutputStream or None on error.
Free the returned object with gobject::ObjectExt::unref.
fn replace_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileOutputStream, Error>) + Send + 'static>(
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
Asynchronously overwrites the file, replacing the contents, possibly creating a backup copy of the file first.
For more details, see File::replace which is
the synchronous version of this call.
When the operation is finished, callback will be called.
You can then call File::replace_finish to get the result
of the operation.
etag
an [entity tag][gfile-etag] for the current File,
or None to ignore
make_backup
true if a backup should be created
flags
a set of FileCreateFlags
io_priority
the [I/O priority][io-priority] of the request
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback to call
when the request is satisfied
user_data
the data to pass to callback function
fn replace_async_future(
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileOutputStream, Error>> + 'static>>
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileOutputStream, Error>> + 'static>>
fn replace_contents<P: IsA<Cancellable>>(
&self,
contents: &[u8],
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<GString, Error>
&self,
contents: &[u8],
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<GString, Error>
Replaces the contents of self with contents of length bytes.
If etag is specified (not None), any existing file must have that etag,
or the error IOErrorEnum::WrongEtag will be returned.
If make_backup is true, this function will attempt to make a backup
of self. Internally, it uses File::replace, so will try to replace the
file contents in the safest way possible. For example, atomic renames are
used when replacing local files’ contents.
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.
The returned new_etag can be used to verify that the file hasn't
changed the next time it is saved over.
contents
a string containing the new contents for self
length
the length of contents in bytes
etag
the old [entity-tag][gfile-etag] for the document,
or None
make_backup
true if a backup should be created
flags
a set of FileCreateFlags
new_etag
a location to a new [entity tag][gfile-etag]
for the document. This should be freed with g_free when no longer
needed, or None
cancellable
optional Cancellable object, None to ignore
Returns
true if successful. If an error has occurred, this function
will return false and set error appropriately if present.
fn replace_readwrite<P: IsA<Cancellable>>(
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileIOStream, Error>
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileIOStream, Error>
Returns an output stream for overwriting the file in readwrite mode, possibly creating a backup copy of the file first. If the file doesn't exist, it will be created.
For details about the behaviour, see File::replace which does the
same thing but returns an output stream only.
Note that in many non-local file cases read and write streams are not supported, so make sure you really need to do read and write streaming, rather than just opening for reading or writing.
etag
an optional [entity tag][gfile-etag]
for the current File, or None to ignore
make_backup
true if a backup should be created
flags
a set of FileCreateFlags
cancellable
optional Cancellable object,
None to ignore
Returns
a FileIOStream or None on error.
Free the returned object with gobject::ObjectExt::unref.
fn replace_readwrite_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileIOStream, Error>) + Send + 'static>(
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
Asynchronously overwrites the file in read-write mode, replacing the contents, possibly creating a backup copy of the file first.
For more details, see File::replace_readwrite which is
the synchronous version of this call.
When the operation is finished, callback will be called.
You can then call File::replace_readwrite_finish to get
the result of the operation.
etag
an [entity tag][gfile-etag] for the current File,
or None to ignore
make_backup
true if a backup should be created
flags
a set of FileCreateFlags
io_priority
the [I/O priority][io-priority] of the request
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback to call
when the request is satisfied
user_data
the data to pass to callback function
fn replace_readwrite_async_future(
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileIOStream, Error>> + 'static>>
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileIOStream, Error>> + 'static>>
fn resolve_relative_path<P: AsRef<Path>>(
&self,
relative_path: P
) -> Option<File>
&self,
relative_path: P
) -> Option<File>
Resolves a relative path for self to an absolute path.
This call does no blocking I/O.
relative_path
a given relative path string
Returns
File to the resolved path.
None if relative_path is None or if self is invalid.
Free the returned object with gobject::ObjectExt::unref.
fn set_attribute_byte_string<P: IsA<Cancellable>>(
&self,
attribute: &str,
value: &str,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
&self,
attribute: &str,
value: &str,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
Sets attribute of type FileAttributeType::ByteString to value.
If attribute is of a different type, this operation will fail,
returning false.
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.
attribute
a string containing the attribute's name
value
a string containing the attribute's new value
flags
a FileQueryInfoFlags
cancellable
optional Cancellable object,
None to ignore
Returns
true if the attribute was successfully set to value
in the self, false otherwise.
fn set_attribute_int32<P: IsA<Cancellable>>(
&self,
attribute: &str,
value: i32,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
&self,
attribute: &str,
value: i32,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
Sets attribute of type FileAttributeType::Int32 to value.
If attribute is of a different type, this operation will fail.
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.
attribute
a string containing the attribute's name
value
a gint32 containing the attribute's new value
flags
a FileQueryInfoFlags
cancellable
optional Cancellable object,
None to ignore
Returns
true if the attribute was successfully set to value
in the self, false otherwise.
fn set_attribute_int64<P: IsA<Cancellable>>(
&self,
attribute: &str,
value: i64,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
&self,
attribute: &str,
value: i64,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
Sets attribute of type FileAttributeType::Int64 to value.
If attribute is of a different type, this operation will fail.
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.
attribute
a string containing the attribute's name
value
a guint64 containing the attribute's new value
flags
a FileQueryInfoFlags
cancellable
optional Cancellable object,
None to ignore
Returns
true if the attribute was successfully set, false otherwise.
fn set_attribute_string<P: IsA<Cancellable>>(
&self,
attribute: &str,
value: &str,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
&self,
attribute: &str,
value: &str,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
Sets attribute of type FileAttributeType::String to value.
If attribute is of a different type, this operation will fail.
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.
attribute
a string containing the attribute's name
value
a string containing the attribute's value
flags
FileQueryInfoFlags
cancellable
optional Cancellable object,
None to ignore
Returns
true if the attribute was successfully set, false otherwise.
fn set_attribute_uint32<P: IsA<Cancellable>>(
&self,
attribute: &str,
value: u32,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
&self,
attribute: &str,
value: u32,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
Sets attribute of type FileAttributeType::Uint32 to value.
If attribute is of a different type, this operation will fail.
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.
attribute
a string containing the attribute's name
value
a guint32 containing the attribute's new value
flags
a FileQueryInfoFlags
cancellable
optional Cancellable object,
None to ignore
Returns
true if the attribute was successfully set to value
in the self, false otherwise.
fn set_attribute_uint64<P: IsA<Cancellable>>(
&self,
attribute: &str,
value: u64,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
&self,
attribute: &str,
value: u64,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
Sets attribute of type FileAttributeType::Uint64 to value.
If attribute is of a different type, this operation will fail.
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.
attribute
a string containing the attribute's name
value
a guint64 containing the attribute's new value
flags
a FileQueryInfoFlags
cancellable
optional Cancellable object,
None to ignore
Returns
true if the attribute was successfully set to value
in the self, false otherwise.
fn set_attributes_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileInfo, Error>) + Send + 'static>(
&self,
info: &FileInfo,
flags: FileQueryInfoFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
&self,
info: &FileInfo,
flags: FileQueryInfoFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
Asynchronously sets the attributes of self with info.
For more details, see File::set_attributes_from_info,
which is the synchronous version of this call.
When the operation is finished, callback will be called.
You can then call File::set_attributes_finish to get
the result of the operation.
info
a FileInfo
flags
a FileQueryInfoFlags
io_priority
the [I/O priority][io-priority] of the request
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback
user_data
a gpointer
fn set_attributes_async_future(
&self,
info: &FileInfo,
flags: FileQueryInfoFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileInfo, Error>> + 'static>>
&self,
info: &FileInfo,
flags: FileQueryInfoFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileInfo, Error>> + 'static>>
fn set_attributes_from_info<P: IsA<Cancellable>>(
&self,
info: &FileInfo,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
&self,
info: &FileInfo,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
Tries to set all attributes in the FileInfo on the target
values, not stopping on the first error.
If there is any error during this operation then error will
be set to the first error. Error on particular fields are flagged
by setting the "status" field in the attribute value to
FileAttributeStatus::ErrorSetting, which means you can
also detect further errors.
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.
info
a FileInfo
flags
FileQueryInfoFlags
cancellable
optional Cancellable object,
None to ignore
Returns
false if there was any error, true otherwise.
fn set_display_name<P: IsA<Cancellable>>(
&self,
display_name: &str,
cancellable: Option<&P>
) -> Result<File, Error>
&self,
display_name: &str,
cancellable: Option<&P>
) -> Result<File, Error>
Renames self to the specified display name.
The display name is converted from UTF-8 to the correct encoding
for the target filesystem if possible and the self is renamed to this.
If you want to implement a rename operation in the user interface the
edit name (G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME) should be used as the
initial value in the rename widget, and then the result after editing
should be passed to File::set_display_name.
On success the resulting converted filename is returned.
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.
display_name
a string
cancellable
optional Cancellable object,
None to ignore
Returns
a File specifying what self was renamed to,
or None if there was an error.
Free the returned object with gobject::ObjectExt::unref.
fn set_display_name_async<P: IsA<Cancellable>, Q: FnOnce(Result<File, Error>) + Send + 'static>(
&self,
display_name: &str,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
&self,
display_name: &str,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
Asynchronously sets the display name for a given File.
For more details, see File::set_display_name which is
the synchronous version of this call.
When the operation is finished, callback will be called.
You can then call File::set_display_name_finish to get
the result of the operation.
display_name
a string
io_priority
the [I/O priority][io-priority] of the request
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback to call
when the request is satisfied
user_data
the data to pass to callback function
fn set_display_name_async_future(
&self,
display_name: &str,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<File, Error>> + 'static>>
&self,
display_name: &str,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<File, Error>> + 'static>>
fn start_mountable<P: IsA<MountOperation>, Q: IsA<Cancellable>, R: FnOnce(Result<(), Error>) + Send + 'static>(
&self,
flags: DriveStartFlags,
start_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)
&self,
flags: DriveStartFlags,
start_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)
Starts a file of type FileType::Mountable.
Using start_operation, you can request callbacks when, for instance,
passwords are needed during authentication.
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.
When the operation is finished, callback will be called.
You can then call File::mount_mountable_finish to get
the result of the operation.
flags
flags affecting the operation
start_operation
a MountOperation, or None to avoid user interaction
cancellable
optional Cancellable object, None to ignore
callback
a GAsyncReadyCallback to call when the request is satisfied, or None
user_data
the data to pass to callback function
fn start_mountable_future<P: IsA<MountOperation> + Clone + 'static>(
&self,
flags: DriveStartFlags,
start_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
&self,
flags: DriveStartFlags,
start_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
fn stop_mountable<P: IsA<MountOperation>, Q: IsA<Cancellable>, R: FnOnce(Result<(), Error>) + Send + 'static>(
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)
Stops a file of type FileType::Mountable.
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.
When the operation is finished, callback will be called.
You can then call File::stop_mountable_finish to get
the result of the operation.
flags
flags affecting the operation
mount_operation
a MountOperation,
or None to avoid user interaction.
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback to call
when the request is satisfied, or None
user_data
the data to pass to callback function
fn stop_mountable_future<P: IsA<MountOperation> + Clone + 'static>(
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
fn supports_thread_contexts(&self) -> bool
Checks if self supports
[thread-default contexts][g-main-context-push-thread-default-context].
If this returns false, you cannot perform asynchronous operations on
self in a thread that has a thread-default context.
Returns
Whether or not self supports thread-default contexts.
fn trash<P: IsA<Cancellable>>(
&self,
cancellable: Option<&P>
) -> Result<(), Error>
&self,
cancellable: Option<&P>
) -> Result<(), Error>
Sends self to the "Trashcan", if possible. This is similar to
deleting it, but the user can recover it before emptying the trashcan.
Not all file systems support trashing, so this call can return the
IOErrorEnum::NotSupported error.
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
Returns
true on successful trash, false otherwise.
fn trash_async<P: IsA<Cancellable>, Q: FnOnce(Result<(), Error>) + Send + 'static>(
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
Asynchronously sends self to the Trash location, if possible.
io_priority
the [I/O priority][io-priority] of the request
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback to call
when the request is satisfied
user_data
the data to pass to callback function
fn trash_async_future(
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
fn unmount_mountable_with_operation<P: IsA<MountOperation>, Q: IsA<Cancellable>, R: FnOnce(Result<(), Error>) + Send + 'static>(
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)
Unmounts a file of type FileType::Mountable.
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.
When the operation is finished, callback will be called.
You can then call File::unmount_mountable_finish to get
the result of the operation.
flags
flags affecting the operation
mount_operation
a MountOperation,
or None to avoid user interaction
cancellable
optional Cancellable object,
None to ignore
callback
a GAsyncReadyCallback to call
when the request is satisfied, or None
user_data
the data to pass to callback function
fn unmount_mountable_with_operation_future<P: IsA<MountOperation> + Clone + 'static>(
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
Implementors
impl<O: IsA<File>> FileExt for O[src]
fn append_to<P: IsA<Cancellable>>(
&self,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileOutputStream, Error>[src]
&self,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileOutputStream, Error>
fn append_to_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileOutputStream, Error>) + Send + 'static>(
&self,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)[src]
&self,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
fn append_to_async_future(
&self,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileOutputStream, Error>> + 'static>>[src]
&self,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileOutputStream, Error>> + 'static>>
fn copy<P: IsA<File>, Q: IsA<Cancellable>>(
&self,
destination: &P,
flags: FileCopyFlags,
cancellable: Option<&Q>,
progress_callback: Option<&mut dyn FnMut(i64, i64)>
) -> Result<(), Error>[src]
&self,
destination: &P,
flags: FileCopyFlags,
cancellable: Option<&Q>,
progress_callback: Option<&mut dyn FnMut(i64, i64)>
) -> Result<(), Error>
fn copy_attributes<P: IsA<File>, Q: IsA<Cancellable>>(
&self,
destination: &P,
flags: FileCopyFlags,
cancellable: Option<&Q>
) -> Result<(), Error>[src]
&self,
destination: &P,
flags: FileCopyFlags,
cancellable: Option<&Q>
) -> Result<(), Error>
fn create<P: IsA<Cancellable>>(
&self,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileOutputStream, Error>[src]
&self,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileOutputStream, Error>
fn create_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileOutputStream, Error>) + Send + 'static>(
&self,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)[src]
&self,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
fn create_async_future(
&self,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileOutputStream, Error>> + 'static>>[src]
&self,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileOutputStream, Error>> + 'static>>
fn create_readwrite<P: IsA<Cancellable>>(
&self,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileIOStream, Error>[src]
&self,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileIOStream, Error>
fn create_readwrite_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileIOStream, Error>) + Send + 'static>(
&self,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)[src]
&self,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
fn create_readwrite_async_future(
&self,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileIOStream, Error>> + 'static>>[src]
&self,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileIOStream, Error>> + 'static>>
fn delete<P: IsA<Cancellable>>(
&self,
cancellable: Option<&P>
) -> Result<(), Error>[src]
&self,
cancellable: Option<&P>
) -> Result<(), Error>
fn delete_async<P: IsA<Cancellable>, Q: FnOnce(Result<(), Error>) + Send + 'static>(
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)[src]
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
fn delete_async_future(
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>[src]
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
fn dup(&self) -> Option<File>[src]
fn eject_mountable_with_operation<P: IsA<MountOperation>, Q: IsA<Cancellable>, R: FnOnce(Result<(), Error>) + Send + 'static>(
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)[src]
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)
fn eject_mountable_with_operation_future<P: IsA<MountOperation> + Clone + 'static>(
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>[src]
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
fn enumerate_children<P: IsA<Cancellable>>(
&self,
attributes: &str,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<FileEnumerator, Error>[src]
&self,
attributes: &str,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<FileEnumerator, Error>
fn equal<P: IsA<File>>(&self, file2: &P) -> bool[src]
fn find_enclosing_mount<P: IsA<Cancellable>>(
&self,
cancellable: Option<&P>
) -> Result<Mount, Error>[src]
&self,
cancellable: Option<&P>
) -> Result<Mount, Error>
fn get_basename(&self) -> Option<PathBuf>[src]
fn get_child<P: AsRef<Path>>(&self, name: P) -> Option<File>[src]
fn get_child_for_display_name(&self, display_name: &str) -> Result<File, Error>[src]
fn get_parent(&self) -> Option<File>[src]
fn get_parse_name(&self) -> Option<GString>[src]
fn get_path(&self) -> Option<PathBuf>[src]
fn get_relative_path<P: IsA<File>>(&self, descendant: &P) -> Option<PathBuf>[src]
fn get_uri(&self) -> GString[src]
fn get_uri_scheme(&self) -> GString[src]
fn has_parent<P: IsA<File>>(&self, parent: Option<&P>) -> bool[src]
fn has_prefix<P: IsA<File>>(&self, prefix: &P) -> bool[src]
fn has_uri_scheme(&self, uri_scheme: &str) -> bool[src]
fn is_native(&self) -> bool[src]
fn load_contents<P: IsA<Cancellable>>(
&self,
cancellable: Option<&P>
) -> Result<(Vec<u8>, GString), Error>[src]
&self,
cancellable: Option<&P>
) -> Result<(Vec<u8>, GString), Error>
fn load_contents_async<P: IsA<Cancellable>, Q: FnOnce(Result<(Vec<u8>, GString), Error>) + Send + 'static>(
&self,
cancellable: Option<&P>,
callback: Q
)[src]
&self,
cancellable: Option<&P>,
callback: Q
)
fn load_contents_async_future(
&self
) -> Pin<Box_<dyn Future<Output = Result<(Vec<u8>, GString), Error>> + 'static>>[src]
&self
) -> Pin<Box_<dyn Future<Output = Result<(Vec<u8>, GString), Error>> + 'static>>
fn make_directory<P: IsA<Cancellable>>(
&self,
cancellable: Option<&P>
) -> Result<(), Error>[src]
&self,
cancellable: Option<&P>
) -> Result<(), Error>
fn make_directory_async<P: IsA<Cancellable>, Q: FnOnce(Result<(), Error>) + Send + 'static>(
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)[src]
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
fn make_directory_async_future(
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>[src]
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
fn make_directory_with_parents<P: IsA<Cancellable>>(
&self,
cancellable: Option<&P>
) -> Result<(), Error>[src]
&self,
cancellable: Option<&P>
) -> Result<(), Error>
fn make_symbolic_link<P: AsRef<Path>, Q: IsA<Cancellable>>(
&self,
symlink_value: P,
cancellable: Option<&Q>
) -> Result<(), Error>[src]
&self,
symlink_value: P,
cancellable: Option<&Q>
) -> Result<(), Error>
fn measure_disk_usage<P: IsA<Cancellable>>(
&self,
flags: FileMeasureFlags,
cancellable: Option<&P>,
progress_callback: Option<Box_<dyn Fn(bool, u64, u64, u64) + 'static>>
) -> Result<(u64, u64, u64), Error>[src]
&self,
flags: FileMeasureFlags,
cancellable: Option<&P>,
progress_callback: Option<Box_<dyn Fn(bool, u64, u64, u64) + 'static>>
) -> Result<(u64, u64, u64), Error>
fn monitor<P: IsA<Cancellable>>(
&self,
flags: FileMonitorFlags,
cancellable: Option<&P>
) -> Result<FileMonitor, Error>[src]
&self,
flags: FileMonitorFlags,
cancellable: Option<&P>
) -> Result<FileMonitor, Error>
fn monitor_directory<P: IsA<Cancellable>>(
&self,
flags: FileMonitorFlags,
cancellable: Option<&P>
) -> Result<FileMonitor, Error>[src]
&self,
flags: FileMonitorFlags,
cancellable: Option<&P>
) -> Result<FileMonitor, Error>
fn monitor_file<P: IsA<Cancellable>>(
&self,
flags: FileMonitorFlags,
cancellable: Option<&P>
) -> Result<FileMonitor, Error>[src]
&self,
flags: FileMonitorFlags,
cancellable: Option<&P>
) -> Result<FileMonitor, Error>
fn mount_enclosing_volume<P: IsA<MountOperation>, Q: IsA<Cancellable>, R: FnOnce(Result<(), Error>) + Send + 'static>(
&self,
flags: MountMountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)[src]
&self,
flags: MountMountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)
fn mount_enclosing_volume_future<P: IsA<MountOperation> + Clone + 'static>(
&self,
flags: MountMountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>[src]
&self,
flags: MountMountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
fn mount_mountable<P: IsA<MountOperation>, Q: IsA<Cancellable>, R: FnOnce(Result<File, Error>) + Send + 'static>(
&self,
flags: MountMountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)[src]
&self,
flags: MountMountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)
fn mount_mountable_future<P: IsA<MountOperation> + Clone + 'static>(
&self,
flags: MountMountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<File, Error>> + 'static>>[src]
&self,
flags: MountMountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<File, Error>> + 'static>>
fn move_<P: IsA<File>, Q: IsA<Cancellable>>(
&self,
destination: &P,
flags: FileCopyFlags,
cancellable: Option<&Q>,
progress_callback: Option<&mut dyn FnMut(i64, i64)>
) -> Result<(), Error>[src]
&self,
destination: &P,
flags: FileCopyFlags,
cancellable: Option<&Q>,
progress_callback: Option<&mut dyn FnMut(i64, i64)>
) -> Result<(), Error>
fn open_readwrite<P: IsA<Cancellable>>(
&self,
cancellable: Option<&P>
) -> Result<FileIOStream, Error>[src]
&self,
cancellable: Option<&P>
) -> Result<FileIOStream, Error>
fn open_readwrite_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileIOStream, Error>) + Send + 'static>(
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)[src]
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
fn open_readwrite_async_future(
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileIOStream, Error>> + 'static>>[src]
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileIOStream, Error>> + 'static>>
fn poll_mountable<P: IsA<Cancellable>, Q: FnOnce(Result<(), Error>) + Send + 'static>(
&self,
cancellable: Option<&P>,
callback: Q
)[src]
&self,
cancellable: Option<&P>,
callback: Q
)
fn poll_mountable_future(
&self
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>[src]
&self
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
fn query_default_handler<P: IsA<Cancellable>>(
&self,
cancellable: Option<&P>
) -> Result<AppInfo, Error>[src]
&self,
cancellable: Option<&P>
) -> Result<AppInfo, Error>
fn query_exists<P: IsA<Cancellable>>(&self, cancellable: Option<&P>) -> bool[src]
fn query_file_type<P: IsA<Cancellable>>(
&self,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> FileType[src]
&self,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> FileType
fn query_filesystem_info<P: IsA<Cancellable>>(
&self,
attributes: &str,
cancellable: Option<&P>
) -> Result<FileInfo, Error>[src]
&self,
attributes: &str,
cancellable: Option<&P>
) -> Result<FileInfo, Error>
fn query_filesystem_info_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileInfo, Error>) + Send + 'static>(
&self,
attributes: &str,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)[src]
&self,
attributes: &str,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
fn query_filesystem_info_async_future(
&self,
attributes: &str,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileInfo, Error>> + 'static>>[src]
&self,
attributes: &str,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileInfo, Error>> + 'static>>
fn query_info<P: IsA<Cancellable>>(
&self,
attributes: &str,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<FileInfo, Error>[src]
&self,
attributes: &str,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<FileInfo, Error>
fn query_info_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileInfo, Error>) + Send + 'static>(
&self,
attributes: &str,
flags: FileQueryInfoFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)[src]
&self,
attributes: &str,
flags: FileQueryInfoFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
fn query_info_async_future(
&self,
attributes: &str,
flags: FileQueryInfoFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileInfo, Error>> + 'static>>[src]
&self,
attributes: &str,
flags: FileQueryInfoFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileInfo, Error>> + 'static>>
fn read<P: IsA<Cancellable>>(
&self,
cancellable: Option<&P>
) -> Result<FileInputStream, Error>[src]
&self,
cancellable: Option<&P>
) -> Result<FileInputStream, Error>
fn read_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileInputStream, Error>) + Send + 'static>(
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)[src]
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
fn read_async_future(
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileInputStream, Error>> + 'static>>[src]
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileInputStream, Error>> + 'static>>
fn replace<P: IsA<Cancellable>>(
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileOutputStream, Error>[src]
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileOutputStream, Error>
fn replace_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileOutputStream, Error>) + Send + 'static>(
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)[src]
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
fn replace_async_future(
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileOutputStream, Error>> + 'static>>[src]
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileOutputStream, Error>> + 'static>>
fn replace_contents<P: IsA<Cancellable>>(
&self,
contents: &[u8],
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<GString, Error>[src]
&self,
contents: &[u8],
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<GString, Error>
fn replace_readwrite<P: IsA<Cancellable>>(
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileIOStream, Error>[src]
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
cancellable: Option<&P>
) -> Result<FileIOStream, Error>
fn replace_readwrite_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileIOStream, Error>) + Send + 'static>(
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)[src]
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
fn replace_readwrite_async_future(
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileIOStream, Error>> + 'static>>[src]
&self,
etag: Option<&str>,
make_backup: bool,
flags: FileCreateFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileIOStream, Error>> + 'static>>
fn resolve_relative_path<P: AsRef<Path>>(
&self,
relative_path: P
) -> Option<File>[src]
&self,
relative_path: P
) -> Option<File>
fn set_attribute_byte_string<P: IsA<Cancellable>>(
&self,
attribute: &str,
value: &str,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>[src]
&self,
attribute: &str,
value: &str,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
fn set_attribute_int32<P: IsA<Cancellable>>(
&self,
attribute: &str,
value: i32,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>[src]
&self,
attribute: &str,
value: i32,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
fn set_attribute_int64<P: IsA<Cancellable>>(
&self,
attribute: &str,
value: i64,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>[src]
&self,
attribute: &str,
value: i64,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
fn set_attribute_string<P: IsA<Cancellable>>(
&self,
attribute: &str,
value: &str,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>[src]
&self,
attribute: &str,
value: &str,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
fn set_attribute_uint32<P: IsA<Cancellable>>(
&self,
attribute: &str,
value: u32,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>[src]
&self,
attribute: &str,
value: u32,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
fn set_attribute_uint64<P: IsA<Cancellable>>(
&self,
attribute: &str,
value: u64,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>[src]
&self,
attribute: &str,
value: u64,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
fn set_attributes_async<P: IsA<Cancellable>, Q: FnOnce(Result<FileInfo, Error>) + Send + 'static>(
&self,
info: &FileInfo,
flags: FileQueryInfoFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)[src]
&self,
info: &FileInfo,
flags: FileQueryInfoFlags,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
fn set_attributes_async_future(
&self,
info: &FileInfo,
flags: FileQueryInfoFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileInfo, Error>> + 'static>>[src]
&self,
info: &FileInfo,
flags: FileQueryInfoFlags,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<FileInfo, Error>> + 'static>>
fn set_attributes_from_info<P: IsA<Cancellable>>(
&self,
info: &FileInfo,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>[src]
&self,
info: &FileInfo,
flags: FileQueryInfoFlags,
cancellable: Option<&P>
) -> Result<(), Error>
fn set_display_name<P: IsA<Cancellable>>(
&self,
display_name: &str,
cancellable: Option<&P>
) -> Result<File, Error>[src]
&self,
display_name: &str,
cancellable: Option<&P>
) -> Result<File, Error>
fn set_display_name_async<P: IsA<Cancellable>, Q: FnOnce(Result<File, Error>) + Send + 'static>(
&self,
display_name: &str,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)[src]
&self,
display_name: &str,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
fn set_display_name_async_future(
&self,
display_name: &str,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<File, Error>> + 'static>>[src]
&self,
display_name: &str,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<File, Error>> + 'static>>
fn start_mountable<P: IsA<MountOperation>, Q: IsA<Cancellable>, R: FnOnce(Result<(), Error>) + Send + 'static>(
&self,
flags: DriveStartFlags,
start_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)[src]
&self,
flags: DriveStartFlags,
start_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)
fn start_mountable_future<P: IsA<MountOperation> + Clone + 'static>(
&self,
flags: DriveStartFlags,
start_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>[src]
&self,
flags: DriveStartFlags,
start_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
fn stop_mountable<P: IsA<MountOperation>, Q: IsA<Cancellable>, R: FnOnce(Result<(), Error>) + Send + 'static>(
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)[src]
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)
fn stop_mountable_future<P: IsA<MountOperation> + Clone + 'static>(
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>[src]
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
fn supports_thread_contexts(&self) -> bool[src]
fn trash<P: IsA<Cancellable>>(
&self,
cancellable: Option<&P>
) -> Result<(), Error>[src]
&self,
cancellable: Option<&P>
) -> Result<(), Error>
fn trash_async<P: IsA<Cancellable>, Q: FnOnce(Result<(), Error>) + Send + 'static>(
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)[src]
&self,
io_priority: Priority,
cancellable: Option<&P>,
callback: Q
)
fn trash_async_future(
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>[src]
&self,
io_priority: Priority
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>
fn unmount_mountable_with_operation<P: IsA<MountOperation>, Q: IsA<Cancellable>, R: FnOnce(Result<(), Error>) + Send + 'static>(
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)[src]
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>,
cancellable: Option<&Q>,
callback: R
)
fn unmount_mountable_with_operation_future<P: IsA<MountOperation> + Clone + 'static>(
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>[src]
&self,
flags: MountUnmountFlags,
mount_operation: Option<&P>
) -> Pin<Box_<dyn Future<Output = Result<(), Error>> + 'static>>