Gio-2.0 ▶ Gio ▶ File ▶ Interface

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 Gio.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 null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

Some file systems don't allow all file names, and may return an Gio.IOErrorEnum.INVALID_FILENAME error. If the file is a directory the Gio.IOErrorEnum.IS_DIRECTORY error will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on.

Asynchronously opens file for appending.

For more details, see g_file_append_to() which is the synchronous version of this call.

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

Finishes an asynchronous file append operation started with g_file_append_to_async().

Copies the file source to the location specified by destination. Can not handle recursive copies of directories.

If the flag Gio.FileCopyFlags.OVERWRITE is specified an already existing destination file is overwritten.

If the flag Gio.FileCopyFlags.NOFOLLOW_SYMLINKS is specified then symlinks will be copied as symlinks, otherwise the target of the source symlink will be copied.

If the flag Gio.FileCopyFlags.ALL_METADATA 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 Gio.FileInfo).

If cancellable is not null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

If progress_callback is not null, then the operation can be monitored by setting this to a Gio.FileProgressCallback 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 source file does not exist, then the Gio.IOErrorEnum.NOT_FOUND error is returned, independent on the status of the destination.

If Gio.FileCopyFlags.OVERWRITE is not specified and the target exists, then the error Gio.IOErrorEnum.EXISTS is returned.

If trying to overwrite a file over a directory, the Gio.IOErrorEnum.IS_DIRECTORY error is returned. If trying to overwrite a directory with a directory the Gio.IOErrorEnum.WOULD_MERGE error is returned.

If the source is a directory and the target does not exist, or Gio.FileCopyFlags.OVERWRITE is specified and the target is a file, then the Gio.IOErrorEnum.WOULD_RECURSE error is returned.

If you are interested in copying the Gio.File object itself (not the on-disk file), see g_file_dup().

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

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

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

Finishes copying the file started with g_file_copy_async().

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 Gio.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 null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

If a file or directory with this name already exists the Gio.IOErrorEnum.EXISTS error will be returned. Some file systems don't allow all file names, and may return an Gio.IOErrorEnum.INVALID_FILENAME error, and if the name is to long Gio.IOErrorEnum.FILENAME_TOO_LONG will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on.

Asynchronously creates a new file and returns an output stream for writing to it. The file must not already exist.

For more details, see g_file_create() which is the synchronous version of this call.

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

Finishes an asynchronous file create operation started with g_file_create_async().

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 Gio.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 null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

If a file or directory with this name already exists, the Gio.IOErrorEnum.EXISTS error will be returned. Some file systems don't allow all file names, and may return an Gio.IOErrorEnum.INVALID_FILENAME error, and if the name is too long, Gio.IOErrorEnum.FILENAME_TOO_LONG 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.

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 g_file_create_readwrite() which is the synchronous version of this call.

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

Finishes an asynchronous file create operation started with g_file_create_readwrite_async().

Deletes a file. If the file is a directory, it will only be deleted if it is empty. This has the same semantics as g_unlink().

If file doesn’t exist, Gio.IOErrorEnum.NOT_FOUND will be returned. This allows for deletion to be implemented avoiding time-of-check to time-of-use races:

g_autoptr(GError) local_error = NULL;
if (!g_file_delete (my_file, my_cancellable, &local_error) &&
    !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
  {
    // deletion failed for some reason other than the file not existing:
    // so report the error
    g_warning ("Failed to delete %s: %s",
               g_file_peek_path (my_file), local_error->message);
  }
Copy

If cancellable is not null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

Asynchronously delete a file. If the file is a directory, it will only be deleted if it is empty. This has the same semantics as g_unlink().

Finishes deleting a file started with g_file_delete_async().

Duplicates a Gio.File handle. This operation does not duplicate the actual file or directory represented by the Gio.File; see g_file_copy() if attempting to copy a file.

g_file_dup() is useful when a second handle is needed to the same underlying file, for use in a separate thread (Gio.File is not thread-safe). For use within the same thread, use g_object_ref() to increment the existing object’s reference count.

This call does no blocking I/O.

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 g_file_eject_mountable_finish().

If cancellable is not null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

Finishes an asynchronous eject operation started by g_file_eject_mountable().

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 g_file_eject_mountable_with_operation_finish().

If cancellable is not null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

Finishes an asynchronous eject operation started by g_file_eject_mountable_with_operation().

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 FILE_ATTRIBUTE_STANDARD_NAME. FILE_ATTRIBUTE_STANDARD_NAME should always be specified if you plan to call FileEnumerator.get_child or FileEnumerator.iterate on the returned enumerator.

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

If the file does not exist, the Gio.IOErrorEnum.NOT_FOUND error will be returned. If the file is not a directory, the Gio.IOErrorEnum.NOT_DIRECTORY error will be returned. Other errors are possible too.

Asynchronously gets the requested information about the files in a directory. The result is a Gio.FileEnumerator object that will give out Gio.FileInfo objects for all the files in the directory.

For more details, see g_file_enumerate_children() which is the synchronous version of this call.

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

Finishes an async enumerate children operation. See g_file_enumerate_children_async().

Checks if the two given GFiles refer to the same file.

This function can be used with Gio.File.hash to insert Gio.Files efficiently in a hash table.

Note that two GFiles that differ can still refer to the same file on the filesystem due to various forms of filename aliasing. For local files, this function essentially compares the file paths, so two Gio.Files which point to different hard or soft links will not be considered equal, despite pointing to the same content.

For determining whether two files are hardlinked, see Gio.FILE_ATTRIBUTE_ID_FILE.

This call does no blocking I/O.

Gets a Gio.Mount for the Gio.File.

Gio.Mount is returned only for user interesting locations, see Gio.VolumeMonitor. If the Gio.FileIface for file does not have a #mount, error will be set to Gio.IOErrorEnum.NOT_FOUND and null #will be returned.

If cancellable is not null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

Asynchronously gets the mount for the file.

For more details, see g_file_find_enclosing_mount() which is the synchronous version of this call.

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

Finishes an asynchronous find mount request. See g_file_find_enclosing_mount_async().

Gets the base name (the last component of the path) for a given Gio.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 g_file_query_info().

This call does no blocking I/O.

Gets the child of file for a given display_name (i.e. a UTF-8 version of the name). If this function fails, it returns null and error will be set. This is very useful when constructing a Gio.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.

Gets the parent directory for the file. If the file represents the root directory of the file system, then null will be returned.

This call does no blocking I/O.

Gets the parse name of the file. A parse name is a UTF-8 string that describes the file such that one can get the Gio.File back using g_file_parse_name().

This is generally used to show the Gio.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.

Gets the local pathname for Gio.File, if one exists. If non-null, this is guaranteed to be an absolute, canonical path. It might contain symlinks.

This call does no blocking I/O.

Gets the path for descendant relative to parent.

This call does no blocking I/O.

Gets the URI for the file.

This call does no blocking I/O.

Gets the URI scheme for a Gio.File. RFC 3986 decodes the scheme as:

URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
Copy

Common schemes include "file", "http", "ftp", etc.

The scheme can be different from the one used to construct the Gio.File, in that it might be replaced with one that is logically equivalent to the Gio.File.

This call does no blocking I/O.

Checks to see if a Gio.File has a given URI scheme.

This call does no blocking I/O.

Creates a hash value for a Gio.File.

This call does no blocking I/O.

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 g_file_get_path() will still return a native path.

This call does no blocking I/O.

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 Gio.File. To recursively create directories, see g_file_make_directory_with_parents().

This function will fail if the parent directory does not exist, setting error to Gio.IOErrorEnum.NOT_FOUND. If the file system doesn't support creating directories, this function will fail, setting error to Gio.IOErrorEnum.NOT_SUPPORTED. If the directory already exists, Gio.IOErrorEnum.EXISTS will be returned.

For a local Gio.File the newly created directory will have the default (current) ownership and permissions of the current process.

If cancellable is not null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

Asynchronously creates a directory.

Finishes an asynchronous directory creation, started with g_file_make_directory_async().

Creates a symbolic link named file which contains the string symlink_value.

If cancellable is not null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

Asynchronously creates a symbolic link named file which contains the string symlink_value.

Finishes an asynchronous symbolic link creation, started with g_file_make_symbolic_link_async().

Recursively measures the disk usage of file.

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 Gio.FileMeasureFlags.REPORT_ANY_ERROR is given in flags.

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

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

Collects the results from an earlier call to g_file_measure_disk_usage_async(). See g_file_measure_disk_usage() for more information.

Obtains a directory monitor for the given file. This may fail if directory monitoring is not supported.

If cancellable is not null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

It does not make sense for flags to contain Gio.FileMonitorFlags.WATCH_HARD_LINKS, 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 g_file_monitor().

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 null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

If flags contains Gio.FileMonitorFlags.WATCH_HARD_LINKS 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 file to be reported. Using this flag may result in an increase in resource usage, and may not have any effect depending on the Gio.FileMonitor backend and/or filesystem type.

Starts a mount_operation, mounting the volume that contains the file location.

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

If cancellable is not null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

Finishes a mount operation started by g_file_mount_enclosing_volume().

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 null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

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

Finishes a mount operation. See g_file_mount_mountable() for details.

Finish an asynchronous mount operation that was started with g_file_mount_mountable().

Tries to move the file or directory source to the location specified by destination. If native move operations are supported then this is used, otherwise a copy + delete fallback is used. The native implementation may support moving directories (for instance on moves inside the same filesystem), but the fallback code does not.

If the flag Gio.FileCopyFlags.OVERWRITE is specified an already existing destination file is overwritten.

If cancellable is not null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

If progress_callback is not null, then the operation can be monitored by setting this to a Gio.FileProgressCallback 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 source file does not exist, then the Gio.IOErrorEnum.NOT_FOUND error is returned, independent on the status of the destination.

If Gio.FileCopyFlags.OVERWRITE is not specified and the target exists, then the error Gio.IOErrorEnum.EXISTS is returned.

If trying to overwrite a file over a directory, the Gio.IOErrorEnum.IS_DIRECTORY error is returned. If trying to overwrite a directory with a directory the Gio.IOErrorEnum.WOULD_MERGE error is returned.

If the source is a directory and the target does not exist, or Gio.FileCopyFlags.OVERWRITE is specified and the target is a file, then the Gio.IOErrorEnum.WOULD_RECURSE error may be returned (if the native move operation isn't available).

Asynchronously moves a file source to the location of destination. For details of the behaviour, see g_file_move().

If progress_callback is not null, then that function that will be called just like in g_file_move(). The callback will run in the default main context of the thread calling g_file_move_async() — the same context as callback is run in.

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

Finishes an asynchronous file movement, started with g_file_move_async().

Opens an existing file for reading and writing. The result is a Gio.FileIOStream that can be used to read and write the contents of the file.

If cancellable is not null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

If the file does not exist, the Gio.IOErrorEnum.NOT_FOUND error will be returned. If the file is a directory, the Gio.IOErrorEnum.IS_DIRECTORY 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.

Asynchronously opens file for reading and writing.

For more details, see g_file_open_readwrite() which is the synchronous version of this call.

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

Finishes an asynchronous file read operation started with g_file_open_readwrite_async().

Polls a file of type Gio.FileType.MOUNTABLE.

If cancellable is not null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

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

Finishes a poll operation. See g_file_poll_mountable() for details.

Finish an asynchronous poll operation that was polled with g_file_poll_mountable().

Checks whether file has the prefix specified by prefix.

In other words, if the names of initial elements of file'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 Gio.File is not a prefix of itself. If you want to check for equality, use g_file_equal().

This call does no I/O, as it works purely on names. As such it can sometimes return false even if file is inside a prefix (from a filesystem point of view), because the prefix of file is an alias of prefix.

Utility function to check if a particular file exists.

The fallback implementation of this API is using Gio.File.query_info and therefore may do blocking I/O. To asynchronously query the existence of a file, use Gio.File.query_info_async.

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 g_file_create() which will either atomically create the file or fail with a Gio.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.

Similar to g_file_query_info(), but obtains information about the filesystem the file 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 null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

If the file does not exist, the Gio.IOErrorEnum.NOT_FOUND error will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on.

Asynchronously gets the requested information about the filesystem that the specified file is on. The result is a Gio.FileInfo object that contains key-value attributes (such as type or size for the file).

For more details, see g_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 g_file_query_info_finish() to get the result of the operation.

Finishes an asynchronous filesystem info query. See g_file_query_filesystem_info_async().

Gets the requested information about specified file.

The result is a Gio.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. In particular this means that if a file is inaccessible (due to being in a folder with restrictive permissions), for example, you can expect the returned Gio.FileInfo to have very few attributes set. You should check whether an attribute is set using Gio.FileInfo.has_attribute before trying to retrieve its value.

It is guaranteed that if any of the following attributes are listed in attributes, they will always be set in the returned Gio.FileInfo, even if the user doesn’t have permissions to access the file:

• Gio.FILE_ATTRIBUTE_STANDARD_NAME
• Gio.FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME

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 might be "standard::*,owner::user". The standard attributes are available as defines, like Gio.FILE_ATTRIBUTE_STANDARD_NAME.

If cancellable is not NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.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 Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS 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 Gio.IOErrorEnum.NOT_FOUND error will be returned. Other errors are possible too, and depend on what kind of file system the file is on.

Asynchronously gets the requested information about specified file. The result is a Gio.FileInfo object that contains key-value attributes (such as type or size for the file).

For more details, see g_file_query_info() which is the synchronous version of this call.

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

Finishes an asynchronous file info query. See g_file_query_info_async().

Obtain the list of settable attributes for the file.

Returns the type and full attribute name of all the attributes that can be set on this file. This doesn't mean setting it will always succeed though, you might get an access failure, or some specific file may not support a specific attribute.

If cancellable is not null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

Obtain the list of attribute namespaces where new attributes can be created by a user. An example of this is extended attributes (in the "xattr" namespace).

If cancellable is not null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

Asynchronously opens file for reading.

For more details, see g_file_read() which is the synchronous version of this call.

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

Finishes an asynchronous file read operation started with g_file_read_async().

Opens a file for reading. The result is a Gio.FileInputStream that can be used to read the contents of the file.

If cancellable is not null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

If the file does not exist, the Gio.IOErrorEnum.NOT_FOUND error will be returned. If the file is a directory, the Gio.IOErrorEnum.IS_DIRECTORY error will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on.

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 Gio.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 null, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error Gio.IOErrorEnum.CANCELLED will be returned.

If you pass in a non-null etag value and file already exists, then this value is compared to the current entity tag of the file, and if they differ an Gio.IOErrorEnum.WRONG_ETAG error is returned. This generally means that the file has been changed since you last read it. You can get the new etag from g_file_output_stream_get_etag() after you've finished writing and closed the Gio.FileOutputStream. When you load a new file you can use g_file_input_stream_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 Gio.IOErrorEnum.CANT_CREATE_BACKUP 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 Gio.IOErrorEnum.IS_DIRECTORY error will be returned, and if the file is some other form of non-regular file then a Gio.IOErrorEnum.NOT_REGULAR_FILE error will be returned. Some file systems don't allow all file names, and may return an Gio.IOErrorEnum.INVALID_FILENAME error, and if the name is to long Gio.IOErrorEnum.FILENAME_TOO_LONG will be returned. Other errors are possible too, and depend on what kind of filesystem the file is on.

Asynchronously overwrites the file, replacing the contents, possibly creating a backup copy of the file first.

For more details, see g_file_replace() which is the synchronous version of this call.