Trait ux::prelude::FileExt[−]

pub trait FileExt: 'static {

Show methods    pub fn append_to<P>(
        &self, 
        flags: FileCreateFlags, 
        cancellable: Option<&P>
    ) -> Result<FileOutputStream, Error>
    where
        P: IsA<Cancellable>;

    pub fn append_to_async<P, Q>(
        &self, 
        flags: FileCreateFlags, 
        io_priority: Priority, 
        cancellable: Option<&P>, 
        callback: Q
    )
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<FileOutputStream, Error>) + Send;

    pub fn append_to_async_future(
        &self, 
        flags: FileCreateFlags, 
        io_priority: Priority
    ) -> Pin<Box<dyn Future<Output = Result<FileOutputStream, Error>> + 'static, Global>>;

    pub fn copy<P, Q>(
        &self, 
        destination: &P, 
        flags: FileCopyFlags, 
        cancellable: Option<&Q>, 
        progress_callback: Option<&mut dyn FnMut(i64, i64)>
    ) -> Result<(), Error>
    where
        P: IsA<File>,
        Q: IsA<Cancellable>;

    pub fn copy_attributes<P, Q>(
        &self, 
        destination: &P, 
        flags: FileCopyFlags, 
        cancellable: Option<&Q>
    ) -> Result<(), Error>
    where
        P: IsA<File>,
        Q: IsA<Cancellable>;

    pub fn create<P>(
        &self, 
        flags: FileCreateFlags, 
        cancellable: Option<&P>
    ) -> Result<FileOutputStream, Error>
    where
        P: IsA<Cancellable>;

    pub fn create_async<P, Q>(
        &self, 
        flags: FileCreateFlags, 
        io_priority: Priority, 
        cancellable: Option<&P>, 
        callback: Q
    )
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<FileOutputStream, Error>) + Send;

    pub fn create_async_future(
        &self, 
        flags: FileCreateFlags, 
        io_priority: Priority
    ) -> Pin<Box<dyn Future<Output = Result<FileOutputStream, Error>> + 'static, Global>>;

    pub fn create_readwrite<P>(
        &self, 
        flags: FileCreateFlags, 
        cancellable: Option<&P>
    ) -> Result<FileIOStream, Error>
    where
        P: IsA<Cancellable>;

    pub fn create_readwrite_async<P, Q>(
        &self, 
        flags: FileCreateFlags, 
        io_priority: Priority, 
        cancellable: Option<&P>, 
        callback: Q
    )
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<FileIOStream, Error>) + Send;

    pub fn create_readwrite_async_future(
        &self, 
        flags: FileCreateFlags, 
        io_priority: Priority
    ) -> Pin<Box<dyn Future<Output = Result<FileIOStream, Error>> + 'static, Global>>;

    pub fn delete<P>(&self, cancellable: Option<&P>) -> Result<(), Error>
    where
        P: IsA<Cancellable>;

    pub fn delete_async<P, Q>(
        &self, 
        io_priority: Priority, 
        cancellable: Option<&P>, 
        callback: Q
    )
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<(), Error>) + Send;

    pub fn delete_async_future(
        &self, 
        io_priority: Priority
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static, Global>>;

    pub fn dup(&self) -> Option<File>;

    pub fn eject_mountable_with_operation<P, Q, R>(
        &self, 
        flags: MountUnmountFlags, 
        mount_operation: Option<&P>, 
        cancellable: Option<&Q>, 
        callback: R
    )
    where
        P: IsA<MountOperation>,
        Q: IsA<Cancellable>,
        R: 'static + FnOnce(Result<(), Error>) + Send;

    pub fn eject_mountable_with_operation_future<P>(
        &self, 
        flags: MountUnmountFlags, 
        mount_operation: Option<&P>
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static, Global>>
    where
        P: 'static + IsA<MountOperation> + Clone;

    pub fn enumerate_children<P>(
        &self, 
        attributes: &str, 
        flags: FileQueryInfoFlags, 
        cancellable: Option<&P>
    ) -> Result<FileEnumerator, Error>
    where
        P: IsA<Cancellable>;

    pub fn equal<P>(&self, file2: &P) -> bool
    where
        P: IsA<File>;

    pub fn find_enclosing_mount<P>(
        &self, 
        cancellable: Option<&P>
    ) -> Result<Mount, Error>
    where
        P: IsA<Cancellable>;

    pub fn get_basename(&self) -> Option<PathBuf>;

    pub fn get_child<P>(&self, name: P) -> Option<File>
    where
        P: AsRef<Path>;

    pub fn get_child_for_display_name(
        &self, 
        display_name: &str
    ) -> Result<File, Error>;

    pub fn get_parent(&self) -> Option<File>;

    pub fn get_parse_name(&self) -> Option<GString>;

    pub fn get_path(&self) -> Option<PathBuf>;

    pub fn get_relative_path<P>(&self, descendant: &P) -> Option<PathBuf>
    where
        P: IsA<File>;

    pub fn get_uri(&self) -> GString;

    pub fn get_uri_scheme(&self) -> GString;

    pub fn has_parent<P>(&self, parent: Option<&P>) -> bool
    where
        P: IsA<File>;

    pub fn has_prefix<P>(&self, prefix: &P) -> bool
    where
        P: IsA<File>;

    pub fn has_uri_scheme(&self, uri_scheme: &str) -> bool;

    pub fn is_native(&self) -> bool;

    pub fn load_bytes<P>(
        &self, 
        cancellable: Option<&P>
    ) -> Result<(Bytes, Option<GString>), Error>
    where
        P: IsA<Cancellable>;

    pub fn load_bytes_async<P, Q>(&self, cancellable: Option<&P>, callback: Q)
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<(Bytes, Option<GString>), Error>) + Send;

    pub fn load_bytes_async_future(
        &self
    ) -> Pin<Box<dyn Future<Output = Result<(Bytes, Option<GString>), Error>> + 'static, Global>>;

    pub fn load_contents<P>(
        &self, 
        cancellable: Option<&P>
    ) -> Result<(Vec<u8, Global>, GString), Error>
    where
        P: IsA<Cancellable>;

    pub fn load_contents_async<P, Q>(
        &self, 
        cancellable: Option<&P>, 
        callback: Q
    )
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<(Vec<u8, Global>, GString), Error>) + Send;

    pub fn load_contents_async_future(
        &self
    ) -> Pin<Box<dyn Future<Output = Result<(Vec<u8, Global>, GString), Error>> + 'static, Global>>;

    pub fn make_directory<P>(
        &self, 
        cancellable: Option<&P>
    ) -> Result<(), Error>
    where
        P: IsA<Cancellable>;

    pub fn make_directory_async<P, Q>(
        &self, 
        io_priority: Priority, 
        cancellable: Option<&P>, 
        callback: Q
    )
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<(), Error>) + Send;

    pub fn make_directory_async_future(
        &self, 
        io_priority: Priority
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static, Global>>;

    pub fn make_directory_with_parents<P>(
        &self, 
        cancellable: Option<&P>
    ) -> Result<(), Error>
    where
        P: IsA<Cancellable>;

    pub fn make_symbolic_link<P, Q>(
        &self, 
        symlink_value: P, 
        cancellable: Option<&Q>
    ) -> Result<(), Error>
    where
        P: AsRef<Path>,
        Q: IsA<Cancellable>;

    pub fn measure_disk_usage<P>(
        &self, 
        flags: FileMeasureFlags, 
        cancellable: Option<&P>, 
        progress_callback: Option<Box<dyn Fn(bool, u64, u64, u64) + 'static, Global>>
    ) -> Result<(u64, u64, u64), Error>
    where
        P: IsA<Cancellable>;

    pub fn monitor<P>(
        &self, 
        flags: FileMonitorFlags, 
        cancellable: Option<&P>
    ) -> Result<FileMonitor, Error>
    where
        P: IsA<Cancellable>;

    pub fn monitor_directory<P>(
        &self, 
        flags: FileMonitorFlags, 
        cancellable: Option<&P>
    ) -> Result<FileMonitor, Error>
    where
        P: IsA<Cancellable>;

    pub fn monitor_file<P>(
        &self, 
        flags: FileMonitorFlags, 
        cancellable: Option<&P>
    ) -> Result<FileMonitor, Error>
    where
        P: IsA<Cancellable>;

    pub fn mount_enclosing_volume<P, Q, R>(
        &self, 
        flags: MountMountFlags, 
        mount_operation: Option<&P>, 
        cancellable: Option<&Q>, 
        callback: R
    )
    where
        P: IsA<MountOperation>,
        Q: IsA<Cancellable>,
        R: 'static + FnOnce(Result<(), Error>) + Send;

    pub fn mount_enclosing_volume_future<P>(
        &self, 
        flags: MountMountFlags, 
        mount_operation: Option<&P>
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static, Global>>
    where
        P: 'static + IsA<MountOperation> + Clone;

    pub fn mount_mountable<P, Q, R>(
        &self, 
        flags: MountMountFlags, 
        mount_operation: Option<&P>, 
        cancellable: Option<&Q>, 
        callback: R
    )
    where
        P: IsA<MountOperation>,
        Q: IsA<Cancellable>,
        R: 'static + FnOnce(Result<File, Error>) + Send;

    pub fn mount_mountable_future<P>(
        &self, 
        flags: MountMountFlags, 
        mount_operation: Option<&P>
    ) -> Pin<Box<dyn Future<Output = Result<File, Error>> + 'static, Global>>
    where
        P: 'static + IsA<MountOperation> + Clone;

    pub fn move_<P, Q>(
        &self, 
        destination: &P, 
        flags: FileCopyFlags, 
        cancellable: Option<&Q>, 
        progress_callback: Option<&mut dyn FnMut(i64, i64)>
    ) -> Result<(), Error>
    where
        P: IsA<File>,
        Q: IsA<Cancellable>;

    pub fn open_readwrite<P>(
        &self, 
        cancellable: Option<&P>
    ) -> Result<FileIOStream, Error>
    where
        P: IsA<Cancellable>;

    pub fn open_readwrite_async<P, Q>(
        &self, 
        io_priority: Priority, 
        cancellable: Option<&P>, 
        callback: Q
    )
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<FileIOStream, Error>) + Send;

    pub fn open_readwrite_async_future(
        &self, 
        io_priority: Priority
    ) -> Pin<Box<dyn Future<Output = Result<FileIOStream, Error>> + 'static, Global>>;

    pub fn peek_path(&self) -> Option<PathBuf>;

    pub fn poll_mountable<P, Q>(&self, cancellable: Option<&P>, callback: Q)
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<(), Error>) + Send;

    pub fn poll_mountable_future(
        &self
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static, Global>>;

    pub fn query_default_handler<P>(
        &self, 
        cancellable: Option<&P>
    ) -> Result<AppInfo, Error>
    where
        P: IsA<Cancellable>;

    pub fn query_exists<P>(&self, cancellable: Option<&P>) -> bool
    where
        P: IsA<Cancellable>;

    pub fn query_file_type<P>(
        &self, 
        flags: FileQueryInfoFlags, 
        cancellable: Option<&P>
    ) -> FileType
    where
        P: IsA<Cancellable>;

    pub fn query_filesystem_info<P>(
        &self, 
        attributes: &str, 
        cancellable: Option<&P>
    ) -> Result<FileInfo, Error>
    where
        P: IsA<Cancellable>;

    pub fn query_filesystem_info_async<P, Q>(
        &self, 
        attributes: &str, 
        io_priority: Priority, 
        cancellable: Option<&P>, 
        callback: Q
    )
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<FileInfo, Error>) + Send;

    pub fn query_filesystem_info_async_future(
        &self, 
        attributes: &str, 
        io_priority: Priority
    ) -> Pin<Box<dyn Future<Output = Result<FileInfo, Error>> + 'static, Global>>;

    pub fn query_info<P>(
        &self, 
        attributes: &str, 
        flags: FileQueryInfoFlags, 
        cancellable: Option<&P>
    ) -> Result<FileInfo, Error>
    where
        P: IsA<Cancellable>;

    pub fn query_info_async<P, Q>(
        &self, 
        attributes: &str, 
        flags: FileQueryInfoFlags, 
        io_priority: Priority, 
        cancellable: Option<&P>, 
        callback: Q
    )
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<FileInfo, Error>) + Send;

    pub fn query_info_async_future(
        &self, 
        attributes: &str, 
        flags: FileQueryInfoFlags, 
        io_priority: Priority
    ) -> Pin<Box<dyn Future<Output = Result<FileInfo, Error>> + 'static, Global>>;

    pub fn read<P>(
        &self, 
        cancellable: Option<&P>
    ) -> Result<FileInputStream, Error>
    where
        P: IsA<Cancellable>;

    pub fn read_async<P, Q>(
        &self, 
        io_priority: Priority, 
        cancellable: Option<&P>, 
        callback: Q
    )
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<FileInputStream, Error>) + Send;

    pub fn read_async_future(
        &self, 
        io_priority: Priority
    ) -> Pin<Box<dyn Future<Output = Result<FileInputStream, Error>> + 'static, Global>>;

    pub fn replace<P>(
        &self, 
        etag: Option<&str>, 
        make_backup: bool, 
        flags: FileCreateFlags, 
        cancellable: Option<&P>
    ) -> Result<FileOutputStream, Error>
    where
        P: IsA<Cancellable>;

    pub fn replace_async<P, Q>(
        &self, 
        etag: Option<&str>, 
        make_backup: bool, 
        flags: FileCreateFlags, 
        io_priority: Priority, 
        cancellable: Option<&P>, 
        callback: Q
    )
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<FileOutputStream, Error>) + Send;

    pub 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, Global>>;

    pub fn replace_contents<P>(
        &self, 
        contents: &[u8], 
        etag: Option<&str>, 
        make_backup: bool, 
        flags: FileCreateFlags, 
        cancellable: Option<&P>
    ) -> Result<GString, Error>
    where
        P: IsA<Cancellable>;

    pub fn replace_readwrite<P>(
        &self, 
        etag: Option<&str>, 
        make_backup: bool, 
        flags: FileCreateFlags, 
        cancellable: Option<&P>
    ) -> Result<FileIOStream, Error>
    where
        P: IsA<Cancellable>;

    pub fn replace_readwrite_async<P, Q>(
        &self, 
        etag: Option<&str>, 
        make_backup: bool, 
        flags: FileCreateFlags, 
        io_priority: Priority, 
        cancellable: Option<&P>, 
        callback: Q
    )
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<FileIOStream, Error>) + Send;

    pub 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, Global>>;

    pub fn resolve_relative_path<P>(&self, relative_path: P) -> Option<File>
    where
        P: AsRef<Path>;

    pub fn set_attribute_byte_string<P>(
        &self, 
        attribute: &str, 
        value: &str, 
        flags: FileQueryInfoFlags, 
        cancellable: Option<&P>
    ) -> Result<(), Error>
    where
        P: IsA<Cancellable>;

    pub fn set_attribute_int32<P>(
        &self, 
        attribute: &str, 
        value: i32, 
        flags: FileQueryInfoFlags, 
        cancellable: Option<&P>
    ) -> Result<(), Error>
    where
        P: IsA<Cancellable>;

    pub fn set_attribute_int64<P>(
        &self, 
        attribute: &str, 
        value: i64, 
        flags: FileQueryInfoFlags, 
        cancellable: Option<&P>
    ) -> Result<(), Error>
    where
        P: IsA<Cancellable>;

    pub fn set_attribute_string<P>(
        &self, 
        attribute: &str, 
        value: &str, 
        flags: FileQueryInfoFlags, 
        cancellable: Option<&P>
    ) -> Result<(), Error>
    where
        P: IsA<Cancellable>;

    pub fn set_attribute_uint32<P>(
        &self, 
        attribute: &str, 
        value: u32, 
        flags: FileQueryInfoFlags, 
        cancellable: Option<&P>
    ) -> Result<(), Error>
    where
        P: IsA<Cancellable>;

    pub fn set_attribute_uint64<P>(
        &self, 
        attribute: &str, 
        value: u64, 
        flags: FileQueryInfoFlags, 
        cancellable: Option<&P>
    ) -> Result<(), Error>
    where
        P: IsA<Cancellable>;

    pub fn set_attributes_async<P, Q>(
        &self, 
        info: &FileInfo, 
        flags: FileQueryInfoFlags, 
        io_priority: Priority, 
        cancellable: Option<&P>, 
        callback: Q
    )
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<FileInfo, Error>) + Send;

    pub fn set_attributes_async_future(
        &self, 
        info: &FileInfo, 
        flags: FileQueryInfoFlags, 
        io_priority: Priority
    ) -> Pin<Box<dyn Future<Output = Result<FileInfo, Error>> + 'static, Global>>;

    pub fn set_attributes_from_info<P>(
        &self, 
        info: &FileInfo, 
        flags: FileQueryInfoFlags, 
        cancellable: Option<&P>
    ) -> Result<(), Error>
    where
        P: IsA<Cancellable>;

    pub fn set_display_name<P>(
        &self, 
        display_name: &str, 
        cancellable: Option<&P>
    ) -> Result<File, Error>
    where
        P: IsA<Cancellable>;

    pub fn set_display_name_async<P, Q>(
        &self, 
        display_name: &str, 
        io_priority: Priority, 
        cancellable: Option<&P>, 
        callback: Q
    )
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<File, Error>) + Send;

    pub fn set_display_name_async_future(
        &self, 
        display_name: &str, 
        io_priority: Priority
    ) -> Pin<Box<dyn Future<Output = Result<File, Error>> + 'static, Global>>;

    pub fn start_mountable<P, Q, R>(
        &self, 
        flags: DriveStartFlags, 
        start_operation: Option<&P>, 
        cancellable: Option<&Q>, 
        callback: R
    )
    where
        P: IsA<MountOperation>,
        Q: IsA<Cancellable>,
        R: 'static + FnOnce(Result<(), Error>) + Send;

    pub fn start_mountable_future<P>(
        &self, 
        flags: DriveStartFlags, 
        start_operation: Option<&P>
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static, Global>>
    where
        P: 'static + IsA<MountOperation> + Clone;

    pub fn stop_mountable<P, Q, R>(
        &self, 
        flags: MountUnmountFlags, 
        mount_operation: Option<&P>, 
        cancellable: Option<&Q>, 
        callback: R
    )
    where
        P: IsA<MountOperation>,
        Q: IsA<Cancellable>,
        R: 'static + FnOnce(Result<(), Error>) + Send;

    pub fn stop_mountable_future<P>(
        &self, 
        flags: MountUnmountFlags, 
        mount_operation: Option<&P>
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static, Global>>
    where
        P: 'static + IsA<MountOperation> + Clone;

    pub fn supports_thread_contexts(&self) -> bool;

    pub fn trash<P>(&self, cancellable: Option<&P>) -> Result<(), Error>
    where
        P: IsA<Cancellable>;

    pub fn trash_async<P, Q>(
        &self, 
        io_priority: Priority, 
        cancellable: Option<&P>, 
        callback: Q
    )
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<(), Error>) + Send;

    pub fn trash_async_future(
        &self, 
        io_priority: Priority
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static, Global>>;

    pub fn unmount_mountable_with_operation<P, Q, R>(
        &self, 
        flags: MountUnmountFlags, 
        mount_operation: Option<&P>, 
        cancellable: Option<&Q>, 
        callback: R
    )
    where
        P: IsA<MountOperation>,
        Q: IsA<Cancellable>,
        R: 'static + FnOnce(Result<(), Error>) + Send;

    pub fn unmount_mountable_with_operation_future<P>(
        &self, 
        flags: MountUnmountFlags, 
        mount_operation: Option<&P>
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static, Global>>
    where
        P: 'static + IsA<MountOperation> + Clone;

}

Required methods

pub fn append_to<P>(
    &self,
    flags: FileCreateFlags,
    cancellable: Option<&P>
) -> Result<FileOutputStream, Error> where
    P: IsA<Cancellable>, 

pub fn append_to_async<P, Q>(
    &self,
    flags: FileCreateFlags,
    io_priority: Priority,
    cancellable: Option<&P>,
    callback: Q
) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<FileOutputStream, Error>) + Send, 

pub fn append_to_async_future(
    &self,
    flags: FileCreateFlags,
    io_priority: Priority
) -> Pin<Box<dyn Future<Output = Result<FileOutputStream, Error>> + 'static, Global>>

pub fn copy<P, Q>(
    &self,
    destination: &P,
    flags: FileCopyFlags,
    cancellable: Option<&Q>,
    progress_callback: Option<&mut dyn FnMut(i64, i64)>
) -> Result<(), Error> where
    P: IsA<File>,
    Q: IsA<Cancellable>, 

pub fn copy_attributes<P, Q>(
    &self,
    destination: &P,
    flags: FileCopyFlags,
    cancellable: Option<&Q>
) -> Result<(), Error> where
    P: IsA<File>,
    Q: IsA<Cancellable>, 

pub fn create<P>(
    &self,
    flags: FileCreateFlags,
    cancellable: Option<&P>
) -> Result<FileOutputStream, Error> where
    P: IsA<Cancellable>, 

pub fn create_async<P, Q>(
    &self,
    flags: FileCreateFlags,
    io_priority: Priority,
    cancellable: Option<&P>,
    callback: Q
) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<FileOutputStream, Error>) + Send, 

pub fn create_async_future(
    &self,
    flags: FileCreateFlags,
    io_priority: Priority
) -> Pin<Box<dyn Future<Output = Result<FileOutputStream, Error>> + 'static, Global>>

pub fn create_readwrite<P>(
    &self,
    flags: FileCreateFlags,
    cancellable: Option<&P>
) -> Result<FileIOStream, Error> where
    P: IsA<Cancellable>, 

pub fn create_readwrite_async<P, Q>(
    &self,
    flags: FileCreateFlags,
    io_priority: Priority,
    cancellable: Option<&P>,
    callback: Q
) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<FileIOStream, Error>) + Send, 

pub fn create_readwrite_async_future(
    &self,
    flags: FileCreateFlags,
    io_priority: Priority
) -> Pin<Box<dyn Future<Output = Result<FileIOStream, Error>> + 'static, Global>>

pub fn delete<P>(&self, cancellable: Option<&P>) -> Result<(), Error> where
    P: IsA<Cancellable>, 

pub fn delete_async<P, Q>(
    &self,
    io_priority: Priority,
    cancellable: Option<&P>,
    callback: Q
) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<(), Error>) + Send, 

pub fn delete_async_future(
    &self,
    io_priority: Priority
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static, Global>>

pub fn dup(&self) -> Option<File>

pub fn eject_mountable_with_operation<P, Q, R>(
    &self,
    flags: MountUnmountFlags,
    mount_operation: Option<&P>,
    cancellable: Option<&Q>,
    callback: R
) where
    P: IsA<MountOperation>,
    Q: IsA<Cancellable>,
    R: 'static + FnOnce(Result<(), Error>) + Send, 

pub fn eject_mountable_with_operation_future<P>(
    &self,
    flags: MountUnmountFlags,
    mount_operation: Option<&P>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static, Global>> where
    P: 'static + IsA<MountOperation> + Clone, 

pub fn enumerate_children<P>(
    &self,
    attributes: &str,
    flags: FileQueryInfoFlags,
    cancellable: Option<&P>
) -> Result<FileEnumerator, Error> where
    P: IsA<Cancellable>, 

pub fn equal<P>(&self, file2: &P) -> bool where
    P: IsA<File>, 

pub fn find_enclosing_mount<P>(
    &self,
    cancellable: Option<&P>
) -> Result<Mount, Error> where
    P: IsA<Cancellable>, 

pub fn get_basename(&self) -> Option<PathBuf>

pub fn get_child<P>(&self, name: P) -> Option<File> where
    P: AsRef<Path>, 

pub fn get_child_for_display_name(
    &self,
    display_name: &str
) -> Result<File, Error>

pub fn get_parent(&self) -> Option<File>

pub fn get_parse_name(&self) -> Option<GString>

pub fn get_path(&self) -> Option<PathBuf>

pub fn get_relative_path<P>(&self, descendant: &P) -> Option<PathBuf> where
    P: IsA<File>, 

pub fn get_uri(&self) -> GString

pub fn get_uri_scheme(&self) -> GString

pub fn has_parent<P>(&self, parent: Option<&P>) -> bool where
    P: IsA<File>, 

pub fn has_prefix<P>(&self, prefix: &P) -> bool where
    P: IsA<File>, 

pub fn has_uri_scheme(&self, uri_scheme: &str) -> bool

pub fn is_native(&self) -> bool

pub fn load_bytes<P>(
    &self,
    cancellable: Option<&P>
) -> Result<(Bytes, Option<GString>), Error> where
    P: IsA<Cancellable>, 

pub fn load_bytes_async<P, Q>(&self, cancellable: Option<&P>, callback: Q) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<(Bytes, Option<GString>), Error>) + Send, 

pub fn load_bytes_async_future(
    &self
) -> Pin<Box<dyn Future<Output = Result<(Bytes, Option<GString>), Error>> + 'static, Global>>

pub fn load_contents<P>(
    &self,
    cancellable: Option<&P>
) -> Result<(Vec<u8, Global>, GString), Error> where
    P: IsA<Cancellable>, 

pub fn load_contents_async<P, Q>(&self, cancellable: Option<&P>, callback: Q) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<(Vec<u8, Global>, GString), Error>) + Send, 

pub fn load_contents_async_future(
    &self
) -> Pin<Box<dyn Future<Output = Result<(Vec<u8, Global>, GString), Error>> + 'static, Global>>

pub fn make_directory<P>(&self, cancellable: Option<&P>) -> Result<(), Error> where
    P: IsA<Cancellable>, 

pub fn make_directory_async<P, Q>(
    &self,
    io_priority: Priority,
    cancellable: Option<&P>,
    callback: Q
) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<(), Error>) + Send, 

pub fn make_directory_async_future(
    &self,
    io_priority: Priority
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static, Global>>

pub fn make_directory_with_parents<P>(
    &self,
    cancellable: Option<&P>
) -> Result<(), Error> where
    P: IsA<Cancellable>, 

pub fn measure_disk_usage<P>(
    &self,
    flags: FileMeasureFlags,
    cancellable: Option<&P>,
    progress_callback: Option<Box<dyn Fn(bool, u64, u64, u64) + 'static, Global>>
) -> Result<(u64, u64, u64), Error> where
    P: IsA<Cancellable>, 

pub fn monitor<P>(
    &self,
    flags: FileMonitorFlags,
    cancellable: Option<&P>
) -> Result<FileMonitor, Error> where
    P: IsA<Cancellable>, 

pub fn monitor_directory<P>(
    &self,
    flags: FileMonitorFlags,
    cancellable: Option<&P>
) -> Result<FileMonitor, Error> where
    P: IsA<Cancellable>, 

pub fn monitor_file<P>(
    &self,
    flags: FileMonitorFlags,
    cancellable: Option<&P>
) -> Result<FileMonitor, Error> where
    P: IsA<Cancellable>, 

pub fn mount_enclosing_volume<P, Q, R>(
    &self,
    flags: MountMountFlags,
    mount_operation: Option<&P>,
    cancellable: Option<&Q>,
    callback: R
) where
    P: IsA<MountOperation>,
    Q: IsA<Cancellable>,
    R: 'static + FnOnce(Result<(), Error>) + Send, 

pub fn mount_enclosing_volume_future<P>(
    &self,
    flags: MountMountFlags,
    mount_operation: Option<&P>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static, Global>> where
    P: 'static + IsA<MountOperation> + Clone, 

pub fn mount_mountable<P, Q, R>(
    &self,
    flags: MountMountFlags,
    mount_operation: Option<&P>,
    cancellable: Option<&Q>,
    callback: R
) where
    P: IsA<MountOperation>,
    Q: IsA<Cancellable>,
    R: 'static + FnOnce(Result<File, Error>) + Send, 

pub fn mount_mountable_future<P>(
    &self,
    flags: MountMountFlags,
    mount_operation: Option<&P>
) -> Pin<Box<dyn Future<Output = Result<File, Error>> + 'static, Global>> where
    P: 'static + IsA<MountOperation> + Clone, 

pub fn move_<P, Q>(
    &self,
    destination: &P,
    flags: FileCopyFlags,
    cancellable: Option<&Q>,
    progress_callback: Option<&mut dyn FnMut(i64, i64)>
) -> Result<(), Error> where
    P: IsA<File>,
    Q: IsA<Cancellable>, 

pub fn open_readwrite<P>(
    &self,
    cancellable: Option<&P>
) -> Result<FileIOStream, Error> where
    P: IsA<Cancellable>, 

pub fn open_readwrite_async<P, Q>(
    &self,
    io_priority: Priority,
    cancellable: Option<&P>,
    callback: Q
) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<FileIOStream, Error>) + Send, 

pub fn open_readwrite_async_future(
    &self,
    io_priority: Priority
) -> Pin<Box<dyn Future<Output = Result<FileIOStream, Error>> + 'static, Global>>

pub fn peek_path(&self) -> Option<PathBuf>

pub fn poll_mountable<P, Q>(&self, cancellable: Option<&P>, callback: Q) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<(), Error>) + Send, 

pub fn poll_mountable_future(
    &self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static, Global>>

pub fn query_default_handler<P>(
    &self,
    cancellable: Option<&P>
) -> Result<AppInfo, Error> where
    P: IsA<Cancellable>, 

pub fn query_exists<P>(&self, cancellable: Option<&P>) -> bool where
    P: IsA<Cancellable>, 

pub fn query_file_type<P>(
    &self,
    flags: FileQueryInfoFlags,
    cancellable: Option<&P>
) -> FileType where
    P: IsA<Cancellable>, 

pub fn query_filesystem_info<P>(
    &self,
    attributes: &str,
    cancellable: Option<&P>
) -> Result<FileInfo, Error> where
    P: IsA<Cancellable>, 

pub fn query_filesystem_info_async<P, Q>(
    &self,
    attributes: &str,
    io_priority: Priority,
    cancellable: Option<&P>,
    callback: Q
) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<FileInfo, Error>) + Send, 

pub fn query_filesystem_info_async_future(
    &self,
    attributes: &str,
    io_priority: Priority
) -> Pin<Box<dyn Future<Output = Result<FileInfo, Error>> + 'static, Global>>

pub fn query_info<P>(
    &self,
    attributes: &str,
    flags: FileQueryInfoFlags,
    cancellable: Option<&P>
) -> Result<FileInfo, Error> where
    P: IsA<Cancellable>, 

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

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

pub fn read<P>(&self, cancellable: Option<&P>) -> Result<FileInputStream, Error> where
    P: IsA<Cancellable>, 

pub fn read_async<P, Q>(
    &self,
    io_priority: Priority,
    cancellable: Option<&P>,
    callback: Q
) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<FileInputStream, Error>) + Send, 

pub fn read_async_future(
    &self,
    io_priority: Priority
) -> Pin<Box<dyn Future<Output = Result<FileInputStream, Error>> + 'static, Global>>

pub fn replace<P>(
    &self,
    etag: Option<&str>,
    make_backup: bool,
    flags: FileCreateFlags,
    cancellable: Option<&P>
) -> Result<FileOutputStream, Error> where
    P: IsA<Cancellable>, 

pub fn replace_async<P, Q>(
    &self,
    etag: Option<&str>,
    make_backup: bool,
    flags: FileCreateFlags,
    io_priority: Priority,
    cancellable: Option<&P>,
    callback: Q
) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<FileOutputStream, Error>) + Send, 

pub 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, Global>>

pub fn replace_contents<P>(
    &self,
    contents: &[u8],
    etag: Option<&str>,
    make_backup: bool,
    flags: FileCreateFlags,
    cancellable: Option<&P>
) -> Result<GString, Error> where
    P: IsA<Cancellable>, 

pub fn replace_readwrite<P>(
    &self,
    etag: Option<&str>,
    make_backup: bool,
    flags: FileCreateFlags,
    cancellable: Option<&P>
) -> Result<FileIOStream, Error> where
    P: IsA<Cancellable>, 

pub fn replace_readwrite_async<P, Q>(
    &self,
    etag: Option<&str>,
    make_backup: bool,
    flags: FileCreateFlags,
    io_priority: Priority,
    cancellable: Option<&P>,
    callback: Q
) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<FileIOStream, Error>) + Send, 

pub 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, Global>>

pub fn resolve_relative_path<P>(&self, relative_path: P) -> Option<File> where
    P: AsRef<Path>, 

pub fn set_attribute_byte_string<P>(
    &self,
    attribute: &str,
    value: &str,
    flags: FileQueryInfoFlags,
    cancellable: Option<&P>
) -> Result<(), Error> where
    P: IsA<Cancellable>, 

pub fn set_attribute_int32<P>(
    &self,
    attribute: &str,
    value: i32,
    flags: FileQueryInfoFlags,
    cancellable: Option<&P>
) -> Result<(), Error> where
    P: IsA<Cancellable>, 

pub fn set_attribute_int64<P>(
    &self,
    attribute: &str,
    value: i64,
    flags: FileQueryInfoFlags,
    cancellable: Option<&P>
) -> Result<(), Error> where
    P: IsA<Cancellable>, 

pub fn set_attribute_string<P>(
    &self,
    attribute: &str,
    value: &str,
    flags: FileQueryInfoFlags,
    cancellable: Option<&P>
) -> Result<(), Error> where
    P: IsA<Cancellable>, 

pub fn set_attribute_uint32<P>(
    &self,
    attribute: &str,
    value: u32,
    flags: FileQueryInfoFlags,
    cancellable: Option<&P>
) -> Result<(), Error> where
    P: IsA<Cancellable>, 

pub fn set_attribute_uint64<P>(
    &self,
    attribute: &str,
    value: u64,
    flags: FileQueryInfoFlags,
    cancellable: Option<&P>
) -> Result<(), Error> where
    P: IsA<Cancellable>, 

pub fn set_attributes_async<P, Q>(
    &self,
    info: &FileInfo,
    flags: FileQueryInfoFlags,
    io_priority: Priority,
    cancellable: Option<&P>,
    callback: Q
) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<FileInfo, Error>) + Send, 

pub fn set_attributes_async_future(
    &self,
    info: &FileInfo,
    flags: FileQueryInfoFlags,
    io_priority: Priority
) -> Pin<Box<dyn Future<Output = Result<FileInfo, Error>> + 'static, Global>>

pub fn set_attributes_from_info<P>(
    &self,
    info: &FileInfo,
    flags: FileQueryInfoFlags,
    cancellable: Option<&P>
) -> Result<(), Error> where
    P: IsA<Cancellable>, 

pub fn set_display_name<P>(
    &self,
    display_name: &str,
    cancellable: Option<&P>
) -> Result<File, Error> where
    P: IsA<Cancellable>, 

pub fn set_display_name_async<P, Q>(
    &self,
    display_name: &str,
    io_priority: Priority,
    cancellable: Option<&P>,
    callback: Q
) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<File, Error>) + Send, 

pub fn set_display_name_async_future(
    &self,
    display_name: &str,
    io_priority: Priority
) -> Pin<Box<dyn Future<Output = Result<File, Error>> + 'static, Global>>

pub fn start_mountable<P, Q, R>(
    &self,
    flags: DriveStartFlags,
    start_operation: Option<&P>,
    cancellable: Option<&Q>,
    callback: R
) where
    P: IsA<MountOperation>,
    Q: IsA<Cancellable>,
    R: 'static + FnOnce(Result<(), Error>) + Send, 

pub fn start_mountable_future<P>(
    &self,
    flags: DriveStartFlags,
    start_operation: Option<&P>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static, Global>> where
    P: 'static + IsA<MountOperation> + Clone, 

pub fn stop_mountable<P, Q, R>(
    &self,
    flags: MountUnmountFlags,
    mount_operation: Option<&P>,
    cancellable: Option<&Q>,
    callback: R
) where
    P: IsA<MountOperation>,
    Q: IsA<Cancellable>,
    R: 'static + FnOnce(Result<(), Error>) + Send, 

pub fn stop_mountable_future<P>(
    &self,
    flags: MountUnmountFlags,
    mount_operation: Option<&P>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static, Global>> where
    P: 'static + IsA<MountOperation> + Clone, 

pub fn supports_thread_contexts(&self) -> bool

pub fn trash<P>(&self, cancellable: Option<&P>) -> Result<(), Error> where
    P: IsA<Cancellable>, 

pub fn trash_async<P, Q>(
    &self,
    io_priority: Priority,
    cancellable: Option<&P>,
    callback: Q
) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<(), Error>) + Send, 

pub fn trash_async_future(
    &self,
    io_priority: Priority
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static, Global>>

pub fn unmount_mountable_with_operation<P, Q, R>(
    &self,
    flags: MountUnmountFlags,
    mount_operation: Option<&P>,
    cancellable: Option<&Q>,
    callback: R
) where
    P: IsA<MountOperation>,
    Q: IsA<Cancellable>,
    R: 'static + FnOnce(Result<(), Error>) + Send, 

pub fn unmount_mountable_with_operation_future<P>(
    &self,
    flags: MountUnmountFlags,
    mount_operation: Option<&P>
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'static, Global>> where
    P: 'static + IsA<MountOperation> + Clone, 

Loading content...

Implementors

impl<O> FileExt for O where
    O: IsA<File>, 

Loading content...