GFile

GFile

Synopsis




                    GFile;
                    GFileIface;
enum                GFileQueryInfoFlags;
enum                GFileCreateFlags;
enum                GFileCopyFlags;
enum                GFileMonitorFlags;
void                (*GFileProgressCallback)            (goffset current_num_bytes,
                                                         goffset total_num_bytes,
                                                         gpointer user_data);
gboolean            (*GFileReadMoreCallback)            (const char *file_contents,
                                                         goffset file_size,
                                                         gpointer callback_data);
GFile*              g_file_new_for_path                 (const char *path);
GFile*              g_file_new_for_uri                  (const char *uri);
GFile*              g_file_new_for_commandline_arg      (const char *arg);
GFile*              g_file_parse_name                   (const char *parse_name);
GFile*              g_file_dup                          (GFile *file);
guint               g_file_hash                         (gconstpointer file);
gboolean            g_file_equal                        (GFile *file1,
                                                         GFile *file2);
char*               g_file_get_basename                 (GFile *file);
char*               g_file_get_path                     (GFile *file);
char*               g_file_get_uri                      (GFile *file);
char*               g_file_get_parse_name               (GFile *file);
GFile*              g_file_get_parent                   (GFile *file);
GFile*              g_file_get_child                    (GFile *file,
                                                         const char *name);
GFile*              g_file_get_child_for_display_name   (GFile *file,
                                                         const char *display_name,
                                                         GError **error);
gboolean            g_file_contains_file                (GFile *parent,
                                                         GFile *descendant);
char*               g_file_get_relative_path            (GFile *parent,
                                                         GFile *descendant);
GFile*              g_file_resolve_relative_path        (GFile *file,
                                                         const char *relative_path);
gboolean            g_file_is_native                    (GFile *file);
gboolean            g_file_has_uri_scheme               (GFile *file,
                                                         const char *uri_scheme);
char*               g_file_get_uri_scheme               (GFile *file);
GFileInputStream*   g_file_read                         (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                g_file_read_async                   (GFile *file,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GFileInputStream*   g_file_read_finish                  (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);
GFileOutputStream*  g_file_append_to                    (GFile *file,
                                                         GFileCreateFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
GFileOutputStream*  g_file_create                       (GFile *file,
                                                         GFileCreateFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
GFileOutputStream*  g_file_replace                      (GFile *file,
                                                         const char *etag,
                                                         gboolean make_backup,
                                                         GFileCreateFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                g_file_append_to_async              (GFile *file,
                                                         GFileCreateFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GFileOutputStream*  g_file_append_to_finish             (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);
void                g_file_create_async                 (GFile *file,
                                                         GFileCreateFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GFileOutputStream*  g_file_create_finish                (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);
void                g_file_replace_async                (GFile *file,
                                                         const char *etag,
                                                         gboolean make_backup,
                                                         GFileCreateFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GFileOutputStream*  g_file_replace_finish               (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);
GFileInfo*          g_file_query_info                   (GFile *file,
                                                         const char *attributes,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                g_file_query_info_async             (GFile *file,
                                                         const char *attributes,
                                                         GFileQueryInfoFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GFileInfo*          g_file_query_info_finish            (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);
GFileInfo*          g_file_query_filesystem_info        (GFile *file,
                                                         const char *attributes,
                                                         GCancellable *cancellable,
                                                         GError **error);
GVolume*            g_file_find_enclosing_volume        (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);
GFileEnumerator*    g_file_enumerate_children           (GFile *file,
                                                         const char *attributes,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                g_file_enumerate_children_async     (GFile *file,
                                                         const char *attributes,
                                                         GFileQueryInfoFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GFileEnumerator*    g_file_enumerate_children_finish    (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);
GFile*              g_file_set_display_name             (GFile *file,
                                                         const char *display_name,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                g_file_set_display_name_async       (GFile *file,
                                                         const char *display_name,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GFile*              g_file_set_display_name_finish      (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);
gboolean            g_file_delete                       (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_trash                        (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_copy                         (GFile *source,
                                                         GFile *destination,
                                                         GFileCopyFlags flags,
                                                         GCancellable *cancellable,
                                                         GFileProgressCallback progress_callback,
                                                         gpointer progress_callback_data,
                                                         GError **error);
gboolean            g_file_move                         (GFile *source,
                                                         GFile *destination,
                                                         GFileCopyFlags flags,
                                                         GCancellable *cancellable,
                                                         GFileProgressCallback progress_callback,
                                                         gpointer progress_callback_data,
                                                         GError **error);
gboolean            g_file_make_directory               (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_make_symbolic_link           (GFile *file,
                                                         const char *symlink_value,
                                                         GCancellable *cancellable,
                                                         GError **error);
GFileAttributeInfoList* g_file_query_settable_attributes
                                                        (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);
GFileAttributeInfoList* g_file_query_writable_namespaces
                                                        (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_set_attribute                (GFile *file,
                                                         const char *attribute,
                                                         const GFileAttributeValue *value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_set_attributes_from_info     (GFile *file,
                                                         GFileInfo *info,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                g_file_set_attributes_async         (GFile *file,
                                                         GFileInfo *info,
                                                         GFileQueryInfoFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            g_file_set_attributes_finish        (GFile *file,
                                                         GAsyncResult *result,
                                                         GFileInfo **info,
                                                         GError **error);
gboolean            g_file_set_attribute_string         (GFile *file,
                                                         const char *attribute,
                                                         const char *value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_set_attribute_byte_string    (GFile *file,
                                                         const char *attribute,
                                                         const char *value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_set_attribute_uint32         (GFile *file,
                                                         const char *attribute,
                                                         guint32 value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_set_attribute_int32          (GFile *file,
                                                         const char *attribute,
                                                         gint32 value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_set_attribute_uint64         (GFile *file,
                                                         const char *attribute,
                                                         guint64 value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            g_file_set_attribute_int64          (GFile *file,
                                                         const char *attribute,
                                                         gint64 value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                g_mount_for_location                (GFile *location,
                                                         GMountOperation *mount_operation,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            g_mount_for_location_finish         (GFile *location,
                                                         GAsyncResult *result,
                                                         GError **error);
void                g_file_mount_mountable              (GFile *file,
                                                         GMountOperation *mount_operation,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
GFile*              g_file_mount_mountable_finish       (GFile *file,
                                                         GAsyncResult *result,
                                                         GError **error);
void                g_file_unmount_mountable            (GFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            g_file_unmount_mountable_finish     (GFile *file,
                                                         GAsyncResult *result,
                                                         GError **error);
void                g_file_eject_mountable              (GFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            g_file_eject_mountable_finish       (GFile *file,
                                                         GAsyncResult *result,
                                                         GError **error);
GDirectoryMonitor*  g_file_monitor_directory            (GFile *file,
                                                         GFileMonitorFlags flags,
                                                         GCancellable *cancellable);
GFileMonitor*       g_file_monitor_file                 (GFile *file,
                                                         GFileMonitorFlags flags,
                                                         GCancellable *cancellable);
gboolean            g_file_load_contents                (GFile *file,
                                                         GCancellable *cancellable,
                                                         char **contents,
                                                         gsize *length,
                                                         char **etag_out,
                                                         GError **error);
void                g_file_load_contents_async          (GFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            g_file_load_contents_finish         (GFile *file,
                                                         GAsyncResult *res,
                                                         char **contents,
                                                         gsize *length,
                                                         char **etag_out,
                                                         GError **error);
void                g_file_load_partial_contents_async  (GFile *file,
                                                         GCancellable *cancellable,
                                                         GFileReadMoreCallback read_more_callback,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            g_file_load_partial_contents_finish (GFile *file,
                                                         GAsyncResult *res,
                                                         char **contents,
                                                         gsize *length,
                                                         char **etag_out,
                                                         GError **error);
gboolean            g_file_replace_contents             (GFile *file,
                                                         const char *contents,
                                                         gsize length,
                                                         const char *etag,
                                                         gboolean make_backup,
                                                         GFileCreateFlags flags,
                                                         char **new_etag,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                g_file_replace_contents_async       (GFile *file,
                                                         const char *contents,
                                                         gsize length,
                                                         const char *etag,
                                                         gboolean make_backup,
                                                         GFileCreateFlags flags,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            g_file_replace_contents_finish      (GFile *file,
                                                         GAsyncResult *res,
                                                         char **new_etag,
                                                         GError **error);


Object Hierarchy


  GInterface
   +----GFile

Prerequisites

GFile requires GObject.

Description

Details

GFile

typedef struct _GFile GFile;


GFileIface

typedef struct {
  GTypeInterface g_iface;

  /* Virtual Table */

  GFile *             (*dup)                        (GFile         *file);
  guint               (*hash)                       (GFile         *file);
  gboolean            (*equal)                      (GFile         *file1,
						     GFile         *file2);
  gboolean            (*is_native)                  (GFile         *file);
  gboolean            (*has_uri_scheme)             (GFile         *file,
						     const char    *uri_scheme);
  char *              (*get_uri_scheme)             (GFile         *file);
  char *              (*get_basename)               (GFile         *file);
  char *              (*get_path)                   (GFile         *file);
  char *              (*get_uri)                    (GFile         *file);
  char *              (*get_parse_name)             (GFile         *file);
  GFile *             (*get_parent)                 (GFile         *file);
  gboolean            (*contains_file)              (GFile         *parent,
						     GFile         *descendant);
  char *              (*get_relative_path)          (GFile         *parent,
						     GFile         *descendant);
  GFile *             (*resolve_relative_path)      (GFile        *file,
						     const char   *relative_path);
  GFile *             (*get_child_for_display_name) (GFile        *file,
						     const char   *display_name,
						     GError      **error);
  
  GFileEnumerator *   (*enumerate_children)        (GFile                *file,
						    const char           *attributes,
						    GFileQueryInfoFlags   flags,
						    GCancellable         *cancellable,
						    GError              **error);
  void                (*enumerate_children_async)  (GFile                      *file,
						    const char                 *attributes,
						    GFileQueryInfoFlags         flags,
						    int                         io_priority,
						    GCancellable               *cancellable,
						    GAsyncReadyCallback         callback,
						    gpointer                    user_data);
  GFileEnumerator *   (*enumerate_children_finish) (GFile                      *file,
						    GAsyncResult               *res,
						    GError                    **error);
  
  GFileInfo *         (*query_info)         (GFile                *file,
					     const char           *attributes,
					     GFileQueryInfoFlags   flags,
					     GCancellable         *cancellable,
					     GError              **error);
  void                (*query_info_async)   (GFile                *file,
					     const char           *attributes,
					     GFileQueryInfoFlags   flags,
					     int                   io_priority,
					     GCancellable         *cancellable,
					     GAsyncReadyCallback   callback,
					     gpointer              user_data);
  GFileInfo *         (*query_info_finish)  (GFile                *file,
					     GAsyncResult         *res,
					     GError              **error);
  
  GFileInfo *         (*query_filesystem_info)(GFile                *file,
					     const char           *attributes,
					     GCancellable         *cancellable,
					     GError              **error);
  void                (*_query_filesystem_info_async) (void);
  void                (*_query_filesystem_info_finish) (void);
  
  GVolume *           (*find_enclosing_volume)(GFile              *file,
					       GCancellable       *cancellable,
					       GError            **error);
  void                (*find_enclosing_volume_async)(GFile              *file,
						     int                   io_priority,
						     GCancellable         *cancellable,
						     GAsyncReadyCallback   callback,
						     gpointer              user_data);
  GVolume *           (*find_enclosing_volume_finish)(GFile              *file,
						      GAsyncResult         *res,
						      GError            **error);
  
  GFile *             (*set_display_name)         (GFile                *file,
						   const char           *display_name,
						   GCancellable         *cancellable,
						   GError              **error);
  void                (*set_display_name_async)   (GFile                      *file,
						   const char                 *display_name,
						   int                         io_priority,
						   GCancellable               *cancellable,
						   GAsyncReadyCallback         callback,
						   gpointer                    user_data);
  GFile *              (*set_display_name_finish) (GFile                      *file,
						   GAsyncResult               *res,
						   GError                    **error);
  
  GFileAttributeInfoList * (*query_settable_attributes) (GFile        *file,
							 GCancellable *cancellable,
							 GError      **error);
  void                (*_query_settable_attributes_async) (void);
  void                (*_query_settable_attributes_finish) (void);
  
  GFileAttributeInfoList * (*query_writable_namespaces) (GFile        *file,
							 GCancellable *cancellable,
							 GError      **error);
  void                (*_query_writable_namespaces_async) (void);
  void                (*_query_writable_namespaces_finish) (void);
  
  gboolean            (*set_attribute)            (GFile                *file,
						   const char           *attribute,
						   const GFileAttributeValue *value,
						   GFileQueryInfoFlags   flags,
						   GCancellable         *cancellable,
						   GError              **error);
  gboolean            (*set_attributes_from_info) (GFile          *file,
						   GFileInfo            *info,
						   GFileQueryInfoFlags   flags,
						   GCancellable         *cancellable,
						   GError              **error);
  void                (*set_attributes_async)     (GFile                      *file,
						   GFileInfo                  *info,
						   GFileQueryInfoFlags        flags,
						   int                         io_priority,
						   GCancellable               *cancellable,
						   GAsyncReadyCallback         callback,
						   gpointer                    user_data);
  gboolean            (*set_attributes_finish)    (GFile                      *file,
						   GAsyncResult               *result,
						   GFileInfo                 **info,
						   GError                    **error);
  
  GFileInputStream *  (*read)               (GFile                *file,
					     GCancellable         *cancellable,
					     GError              **error);
  void                (*read_async)         (GFile                *file,
					     int                   io_priority,
					     GCancellable         *cancellable,
					     GAsyncReadyCallback   callback,
					     gpointer              user_data);
  GFileInputStream *  (*read_finish)        (GFile                *file,
					     GAsyncResult         *res,
					     GError              **error);
  
  GFileOutputStream * (*append_to)          (GFile                *file,
					     GFileCreateFlags      flags,
					     GCancellable         *cancellable,
					     GError               **error);
  void                 (*append_to_async)   (GFile                      *file,
					     GFileCreateFlags            flags,
					     int                         io_priority,
					     GCancellable               *cancellable,
					     GAsyncReadyCallback         callback,
					     gpointer                    user_data);
  GFileOutputStream *  (*append_to_finish)  (GFile                      *file,
					     GAsyncResult               *res,
					     GError                    **error);
  
  GFileOutputStream * (*create)             (GFile                *file,
					     GFileCreateFlags      flags,
					     GCancellable         *cancellable,
					     GError               **error);
  void                 (*create_async)      (GFile                      *file,
					     GFileCreateFlags            flags,
					     int                         io_priority,
					     GCancellable               *cancellable,
					     GAsyncReadyCallback         callback,
					     gpointer                    user_data);
  GFileOutputStream *  (*create_finish)     (GFile                      *file,
					     GAsyncResult               *res,
					     GError                    **error);
  
  GFileOutputStream *  (*replace)           (GFile                *file,
					     const char           *etag,
					     gboolean              make_backup,
					     GFileCreateFlags      flags,
					     GCancellable         *cancellable,
					     GError              **error);
  void                 (*replace_async)     (GFile                      *file,
					     const char                 *etag,
					     gboolean                    make_backup,
					     GFileCreateFlags            flags,
					     int                         io_priority,
					     GCancellable               *cancellable,
					     GAsyncReadyCallback         callback,
					     gpointer                    user_data);
  GFileOutputStream *  (*replace_finish)    (GFile                      *file,
					     GAsyncResult               *res,
					     GError                    **error);
  
  gboolean            (*delete_file)        (GFile                *file,
					     GCancellable         *cancellable,
					     GError              **error);
  void                (*_delete_file_async) (void);
  void                (*_delete_file_finish) (void);
  
  gboolean            (*trash)              (GFile                *file,
					     GCancellable         *cancellable,
					     GError              **error);
  void                (*_trash_async) (void);
  void                (*_trash_finish) (void);
  
  gboolean            (*make_directory)     (GFile                *file,
					     GCancellable         *cancellable,
					     GError              **error);
  void                (*_make_directory_async) (void);
  void                (*_make_directory_finish) (void);
  
  gboolean            (*make_symbolic_link) (GFile                *file,
					     const char           *symlink_value,
					     GCancellable         *cancellable,
					     GError              **error);
  void                (*_make_symbolic_link_async) (void);
  void                (*_make_symbolic_link_finish) (void);
  
  gboolean            (*copy)               (GFile                *source,
					     GFile                *destination,
					     GFileCopyFlags        flags,
					     GCancellable         *cancellable,
					     GFileProgressCallback progress_callback,
					     gpointer              progress_callback_data,
					     GError              **error);
  void                (*_copy_async) (void);
  void                (*_copy_finish) (void);
  
  gboolean            (*move)               (GFile                *source,
					     GFile                *destination,
					     GFileCopyFlags        flags,
					     GCancellable         *cancellable,
					     GFileProgressCallback progress_callback,
					     gpointer              progress_callback_data,
					     GError              **error);

  void                (*_move_async) (void);
  void                (*_move_finish) (void);


  void                (*mount_mountable)           (GFile               *file,
						    GMountOperation     *mount_operation,
						    GCancellable         *cancellable,
						    GAsyncReadyCallback  callback,
						    gpointer             user_data);
  GFile *             (*mount_mountable_finish)    (GFile               *file,
						    GAsyncResult        *result,
						    GError             **error);
  void                (*unmount_mountable)         (GFile               *file,
						    GCancellable         *cancellable,
						    GAsyncReadyCallback  callback,
						    gpointer             user_data);
  gboolean            (*unmount_mountable_finish)  (GFile               *file,
						    GAsyncResult        *result,
						    GError             **error);
  void                (*eject_mountable)           (GFile               *file,
						    GCancellable        *cancellable,
						    GAsyncReadyCallback  callback,
						    gpointer             user_data);
  gboolean            (*eject_mountable_finish)    (GFile               *file,
						    GAsyncResult        *result,
						    GError             **error);


  void     (*mount_for_location)        (GFile *location,
					 GMountOperation *mount_operation,
					 GCancellable *cancellable,
					 GAsyncReadyCallback callback,
					 gpointer user_data);
  gboolean (*mount_for_location_finish) (GFile *location,
					 GAsyncResult *result,
					 GError **error);
  
  GDirectoryMonitor* (*monitor_dir)         (GFile                  *file,
					     GFileMonitorFlags       flags,
					     GCancellable           *cancellable);

  GFileMonitor*      (*monitor_file)        (GFile                  *file,
					     GFileMonitorFlags       flags,
					     GCancellable           *cancellable);


    /* Padding for future expansion */
  void (*_g_reserved1) (void);
  void (*_g_reserved2) (void);
  void (*_g_reserved3) (void);
  void (*_g_reserved4) (void);
  void (*_g_reserved5) (void);
  void (*_g_reserved6) (void);
  void (*_g_reserved7) (void);
  void (*_g_reserved8) (void);
  void (*_g_reserved9) (void);
  void (*_g_reserved10) (void);
  void (*_g_reserved11) (void);
  void (*_g_reserved12) (void);
  void (*_g_reserved13) (void);
  void (*_g_reserved14) (void);
  void (*_g_reserved15) (void);
  void (*_g_reserved16) (void);
  void (*_g_reserved17) (void);
  void (*_g_reserved18) (void);
  void (*_g_reserved19) (void);
  void (*_g_reserved20) (void);
} GFileIface;


enum GFileQueryInfoFlags

typedef enum {
  G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS = (1<<0)
} GFileQueryInfoFlags;


enum GFileCreateFlags

typedef enum  {
  G_FILE_CREATE_FLAGS_NONE = 0,
  G_FILE_CREATE_FLAGS_PRIVATE = (1<<0)
} GFileCreateFlags;


enum GFileCopyFlags

typedef enum {
  G_FILE_COPY_OVERWRITE = (1<<0),
  G_FILE_COPY_BACKUP = (1<<1),
  G_FILE_COPY_NOFOLLOW_SYMLINKS = (1<<2),
  G_FILE_COPY_ALL_METADATA = (1<<3),
} GFileCopyFlags;


enum GFileMonitorFlags

typedef enum  {
  G_FILE_MONITOR_FLAGS_NONE = 0,
  G_FILE_MONITOR_FLAGS_MONITOR_MOUNTS = (1<<0)
} GFileMonitorFlags;


GFileProgressCallback ()

void                (*GFileProgressCallback)            (goffset current_num_bytes,
                                                         goffset total_num_bytes,
                                                         gpointer user_data);

current_num_bytes :

total_num_bytes :

user_data :


GFileReadMoreCallback ()

gboolean            (*GFileReadMoreCallback)            (const char *file_contents,
                                                         goffset file_size,
                                                         gpointer callback_data);

file_contents :

file_size :

callback_data :

Returns :


g_file_new_for_path ()

GFile*              g_file_new_for_path                 (const char *path);

path :

Returns :

a new GFile for the given path, NULL on error.

g_file_new_for_uri ()

GFile*              g_file_new_for_uri                  (const char *uri);

uri :

Returns :

a GFile with the given uri, NULL on error.

g_file_new_for_commandline_arg ()

GFile*              g_file_new_for_commandline_arg      (const char *arg);

arg :

Returns :

a new GFile.

g_file_parse_name ()

GFile*              g_file_parse_name                   (const char *parse_name);

parse_name :

Returns :

a GFile with the parse_name, NULL on error.

g_file_dup ()

GFile*              g_file_dup                          (GFile *file);

file :

input GFile.

Returns :

GFile that is a duplicate of the given GFile, or NULL if given GFile is invalid.

g_file_hash ()

guint               g_file_hash                         (gconstpointer file);

file :

gconstpointer to a GFile.

Returns :

0 if file is not a GFile, otherwise a guint containing a hash of the GFile. This function is intended for easily hashing a GFile to add to a GHashTable or similar data structure. TODO: What is the hash representative of, the name? contents? path? implementation specific?

g_file_equal ()

gboolean            g_file_equal                        (GFile *file1,
                                                         GFile *file2);

file1 :

pointer to the first GFile.

file2 :

pointer to the second GFile.

Returns :

TRUE if file1 and file2 are equal. FALSE if either is not a GFile.

g_file_get_basename ()

char*               g_file_get_basename                 (GFile *file);

file :

input GFile.

Returns :

string containing the GFile's base name, or NULL if given GFile is invalid. TODO: is the returned string owned by GIO?

g_file_get_path ()

char*               g_file_get_path                     (GFile *file);

file :

input GFile.

Returns :

string containing the GFile's path, or NULL if given GFile is invalid. TODO: is the returned string owned by GIO?

g_file_get_uri ()

char*               g_file_get_uri                      (GFile *file);

file :

input GFile.

Returns :

string to the GFile's Universal Resource Identifier (URI), or NULL if given GFile is invalid. TODO: is the returned string owned by GIO?

g_file_get_parse_name ()

char*               g_file_get_parse_name               (GFile *file);

file :

Returns :


g_file_get_parent ()

GFile*              g_file_get_parent                   (GFile *file);

file :

input GFile.

Returns :

a GFile structure to the parent of the given GFile. TODO: What kind of parent? Directory if the child is a file or directory? Little big of clarification would be good.

g_file_get_child ()

GFile*              g_file_get_child                    (GFile *file,
                                                         const char *name);

file :

input GFile.

name :

string containing the child's name.

Returns :

a GFile pointer to a child specified by name or NULL if name is NULL, or the specified child doesn't exist.

g_file_get_child_for_display_name ()

GFile*              g_file_get_child_for_display_name   (GFile *file,
                                                         const char *display_name,
                                                         GError **error);

file :

input GFile.

display_name :

string to a possible child.

error :

GError.

Returns :

NULL if display_name is NULL, GFile to the specified child.

g_file_contains_file ()

gboolean            g_file_contains_file                (GFile *parent,
                                                         GFile *descendant);

parent :

input GFile.

descendant :

input GFile.

Returns :

FALSE if either the parent or descendant is invalid. TRUE if the descendent's parent is parent.

g_file_get_relative_path ()

char*               g_file_get_relative_path            (GFile *parent,
                                                         GFile *descendant);

parent :

input GFile.

descendant :

input GFile.

Returns :

string with the relative path from descendant to parent. TODO: is the returned value owned by GIO?

g_file_resolve_relative_path ()

GFile*              g_file_resolve_relative_path        (GFile *file,
                                                         const char *relative_path);

file :

input GFile.

relative_path :

a given relative path string.

Returns :

GFile to the resolved path. NULL if relative_path is NULL. or if file is invalid.

g_file_is_native ()

gboolean            g_file_is_native                    (GFile *file);

file :

input GFile.

Returns :

TRUE if file is native. TODO: Explain what "native" means.

g_file_has_uri_scheme ()

gboolean            g_file_has_uri_scheme               (GFile *file,
                                                         const char *uri_scheme);

file :

input GFile.

uri_scheme :

const char* to a URI scheme.

Returns :

TRUE if GFile's backend supports the given URI scheme, FALSE if URI scheme is NULL, not supported, or GFile is invalid.

g_file_get_uri_scheme ()

char*               g_file_get_uri_scheme               (GFile *file);

file :

input GFile.

Returns :

string to the URI scheme for the given GFile. TODO: is the returned string owned by GIO?

g_file_read ()

GFileInputStream*   g_file_read                         (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);

Reads a whole file into a GFileInputStream. Fails returning NULL if given GFile points to a directory.

file :

GFile to read.

cancellable :

GCancellable

error :

GError.

Returns :

GFileInputStream or NULL.

g_file_read_async ()

void                g_file_read_async                   (GFile *file,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

file :

input GFile.

io_priority :

cancellable :

GCancellable interrupt object.

callback :

user_data :


g_file_read_finish ()

GFileInputStream*   g_file_read_finish                  (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);

file :

input GFile.

res :

error :

Returns :


g_file_append_to ()

GFileOutputStream*  g_file_append_to                    (GFile *file,
                                                         GFileCreateFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

flags :

cancellable :

GCancellable interrupt object.

error :

Returns :


g_file_create ()

GFileOutputStream*  g_file_create                       (GFile *file,
                                                         GFileCreateFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

flags :

cancellable :

GCancellable interrupt object.

error :

Returns :


g_file_replace ()

GFileOutputStream*  g_file_replace                      (GFile *file,
                                                         const char *etag,
                                                         gboolean make_backup,
                                                         GFileCreateFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

etag :

make_backup :

flags :

cancellable :

GCancellable interrupt object.

error :

Returns :


g_file_append_to_async ()

void                g_file_append_to_async              (GFile *file,
                                                         GFileCreateFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

file :

input GFile.

flags :

io_priority :

cancellable :

GCancellable interrupt object.

callback :

user_data :


g_file_append_to_finish ()

GFileOutputStream*  g_file_append_to_finish             (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);

file :

input GFile.

res :

GAsyncResult

error :

Returns :

a valid GFileOutputStream or NULL upon error.

g_file_create_async ()

void                g_file_create_async                 (GFile *file,
                                                         GFileCreateFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

file :

input GFile.

flags :

io_priority :

cancellable :

GCancellable interrupt object.

callback :

user_data :


g_file_create_finish ()

GFileOutputStream*  g_file_create_finish                (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);

file :

input GFile.

res :

error :

Returns :

GFileOutputStream

g_file_replace_async ()

void                g_file_replace_async                (GFile *file,
                                                         const char *etag,
                                                         gboolean make_backup,
                                                         GFileCreateFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

file :

input GFile.

etag :

make_backup :

flags :

io_priority :

cancellable :

GCancellable interrupt object.

callback :

user_data :


g_file_replace_finish ()

GFileOutputStream*  g_file_replace_finish               (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);

file :

input GFile.

res :

error :

Returns :

GFileOutputStream.

g_file_query_info ()

GFileInfo*          g_file_query_info                   (GFile *file,
                                                         const char *attributes,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

attributes :

flags :

cancellable :

error :

Returns :

a GFileInfo for the given file, or NULL on error.

g_file_query_info_async ()

void                g_file_query_info_async             (GFile *file,
                                                         const char *attributes,
                                                         GFileQueryInfoFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

file :

input GFile.

attributes :

flags :

io_priority :

cancellable :

callback :

user_data :


g_file_query_info_finish ()

GFileInfo*          g_file_query_info_finish            (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);

file :

input GFile.

res :

error :

Returns :

GFileInfo for given file.

g_file_query_filesystem_info ()

GFileInfo*          g_file_query_filesystem_info        (GFile *file,
                                                         const char *attributes,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

attributes :

cancellable :

error :

Returns :


g_file_find_enclosing_volume ()

GVolume*            g_file_find_enclosing_volume        (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

cancellable :

error :

Returns :


g_file_enumerate_children ()

GFileEnumerator*    g_file_enumerate_children           (GFile *file,
                                                         const char *attributes,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

attributes :

flags :

GFileQueryInfoFlags field.

cancellable :

GCancellable interrupt object.

error :

GError for error reporting.

Returns :

NULL if cancelled or if GFile's backend doesn't support GFileEnumerator. Returns a pointer to a GFileEnumerator if successful.

g_file_enumerate_children_async ()

void                g_file_enumerate_children_async     (GFile *file,
                                                         const char *attributes,
                                                         GFileQueryInfoFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

file :

input GFile.

attributes :

flags :

io_priority :

cancellable :

callback :

user_data :


g_file_enumerate_children_finish ()

GFileEnumerator*    g_file_enumerate_children_finish    (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);

file :

input GFile.

res :

error :

Returns :

GFileEnumerator.

g_file_set_display_name ()

GFile*              g_file_set_display_name             (GFile *file,
                                                         const char *display_name,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

display_name :

cancellable :

GCancellable interrupt object.

error :

Returns :


g_file_set_display_name_async ()

void                g_file_set_display_name_async       (GFile *file,
                                                         const char *display_name,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

file :

input GFile.

display_name :

io_priority :

cancellable :

GCancellable interrupt object.

callback :

user_data :


g_file_set_display_name_finish ()

GFile*              g_file_set_display_name_finish      (GFile *file,
                                                         GAsyncResult *res,
                                                         GError **error);

file :

input GFile.

res :

error :

Returns :


g_file_delete ()

gboolean            g_file_delete                       (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

cancellable :

GCancellable interrupt object.

error :

Returns :


g_file_trash ()

gboolean            g_file_trash                        (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);

This function sends the object to the virtual "Trash" location. If the GFile interface does not have a corresponding "Trash" location, this function returns FALSE, and will set error appropriately.

file :

GFile to location to send to trash.

cancellable :

GCancellable interrupt object.

error :

GError for possible failures.

Returns :

TRUE on successful trash, FALSE otherwise.

g_file_copy ()

gboolean            g_file_copy                         (GFile *source,
                                                         GFile *destination,
                                                         GFileCopyFlags flags,
                                                         GCancellable *cancellable,
                                                         GFileProgressCallback progress_callback,
                                                         gpointer progress_callback_data,
                                                         GError **error);

List of possible errors resulting from g_file_copy(): source dest flags res - * * G_IO_ERROR_NOT_FOUND file - * ok file * 0 G_IO_ERROR_EXISTS file file overwr ok file dir overwr G_IO_ERROR_IS_DIRECTORY dir - * G_IO_ERROR_WOULD_RECURSE dir * 0 G_IO_ERROR_EXISTS dir dir overwr G_IO_ERROR_IS_DIRECTORY dir file overwr G_IO_ERROR_WOULD_RECURSE

source :

input GFile.

destination :

destination GFile

flags :

set of GFileCopyFlags

cancellable :

GCancellable interrupt object.

progress_callback :

function to callback with progress information

progress_callback_data :

userdata to pass to progress_callback

error :

GError to set on error

Returns :

TRUE on success, FALSE otherwise.

g_file_move ()

gboolean            g_file_move                         (GFile *source,
                                                         GFile *destination,
                                                         GFileCopyFlags flags,
                                                         GCancellable *cancellable,
                                                         GFileProgressCallback progress_callback,
                                                         gpointer progress_callback_data,
                                                         GError **error);

List of possible returns from g_file_move() with given source, destination, and flags:

source dest flags results in - * * G_IO_ERROR_NOT_FOUND file - * ok file * 0 G_IO_ERROR_EXISTS file file overwr ok file dir overwr G_IO_ERROR_IS_DIRECTORY

dir - * ok || G_IO_ERROR_WOULD_RECURSE dir * 0 G_IO_ERROR_EXISTS dir dir overwr G_IO_ERROR_IS_DIRECTORY dir file overwr ok || G_IO_ERROR_WOULD_RECURSE

source :

GFile* pointing to the source location.

destination :

GFile* pointing to the destination location.

flags :

GFileCopyFlags enum.

cancellable :

GCancellable interrupt object.

progress_callback :

GFileProgressCallback function for updates.

progress_callback_data :

gpointer to user data for the callback function.

error :

GError for returning error conditions.

Returns :

TRUE on successful move, FALSE otherwise.

g_file_make_directory ()

gboolean            g_file_make_directory               (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

cancellable :

GCancellable interrupt object.

error :

Returns :


g_file_make_symbolic_link ()

gboolean            g_file_make_symbolic_link           (GFile *file,
                                                         const char *symlink_value,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

symlink_value :

cancellable :

GCancellable interrupt object.

error :

Returns :


g_file_query_settable_attributes ()

GFileAttributeInfoList* g_file_query_settable_attributes
                                                        (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

cancellable :

GCancellable interrupt object.

error :

Returns :

the type and full attribute name of all the attributes that the file can set. 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.

g_file_query_writable_namespaces ()

GFileAttributeInfoList* g_file_query_writable_namespaces
                                                        (GFile *file,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

cancellable :

GCancellable interrupt object.

error :

Returns :

the list of attribute namespaces where the user can create their own attribute names, such as extended attributes.

g_file_set_attribute ()

gboolean            g_file_set_attribute                (GFile *file,
                                                         const char *attribute,
                                                         const GFileAttributeValue *value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

attribute :

the attribute to set's name.

value :

GFileAttributeValue

flags :

GFileQueryInfoFlags

cancellable :

GCancellable interrupt object.

error :

Returns :


g_file_set_attributes_from_info ()

gboolean            g_file_set_attributes_from_info     (GFile *file,
                                                         GFileInfo *info,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

Tries to set all attributes in the GFileInfo on the target values, not stopping on the first error.

file :

input GFile.

info :

flags :

GFileQueryInfoFlags

cancellable :

GCancellable interrupt object.

error :

Returns :

TRUE if there was any error, and *error will be set to the first error. Error on particular fields are flagged by setting the "status" field in the attribute value to G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING.

g_file_set_attributes_async ()

void                g_file_set_attributes_async         (GFile *file,
                                                         GFileInfo *info,
                                                         GFileQueryInfoFlags flags,
                                                         int io_priority,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

file :

input GFile.

info :

flags :

io_priority :

cancellable :

GCancellable interrupt object.

callback :

user_data :


g_file_set_attributes_finish ()

gboolean            g_file_set_attributes_finish        (GFile *file,
                                                         GAsyncResult *result,
                                                         GFileInfo **info,
                                                         GError **error);

file :

input GFile.

result :

info :

error :

Returns :


g_file_set_attribute_string ()

gboolean            g_file_set_attribute_string         (GFile *file,
                                                         const char *attribute,
                                                         const char *value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

attribute :

value :

flags :

cancellable :

GCancellable interrupt object.

error :

Returns :


g_file_set_attribute_byte_string ()

gboolean            g_file_set_attribute_byte_string    (GFile *file,
                                                         const char *attribute,
                                                         const char *value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

attribute :

value :

flags :

cancellable :

error :

Returns :


g_file_set_attribute_uint32 ()

gboolean            g_file_set_attribute_uint32         (GFile *file,
                                                         const char *attribute,
                                                         guint32 value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

attribute :

value :

flags :

cancellable :

GCancellable interrupt object.

error :

Returns :


g_file_set_attribute_int32 ()

gboolean            g_file_set_attribute_int32          (GFile *file,
                                                         const char *attribute,
                                                         gint32 value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

attribute :

value :

flags :

cancellable :

GCancellable interrupt object.

error :

Returns :


g_file_set_attribute_uint64 ()

gboolean            g_file_set_attribute_uint64         (GFile *file,
                                                         const char *attribute,
                                                         guint64 value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

attribute :

value :

flags :

cancellable :

GCancellable interrupt object.

error :

Returns :


g_file_set_attribute_int64 ()

gboolean            g_file_set_attribute_int64          (GFile *file,
                                                         const char *attribute,
                                                         gint64 value,
                                                         GFileQueryInfoFlags flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

attribute :

value :

flags :

cancellable :

GCancellable interrupt object.

error :

Returns :


g_mount_for_location ()

void                g_mount_for_location                (GFile *location,
                                                         GMountOperation *mount_operation,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

location :

input GFile.

mount_operation :

cancellable :

GCancellable interrupt object.

callback :

user_data :


g_mount_for_location_finish ()

gboolean            g_mount_for_location_finish         (GFile *location,
                                                         GAsyncResult *result,
                                                         GError **error);

location :

input GFile.

result :

error :

Returns :


g_file_mount_mountable ()

void                g_file_mount_mountable              (GFile *file,
                                                         GMountOperation *mount_operation,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

file :

input GFile.

mount_operation :

cancellable :

GCancellable interrupt object.

callback :

user_data :


g_file_mount_mountable_finish ()

GFile*              g_file_mount_mountable_finish       (GFile *file,
                                                         GAsyncResult *result,
                                                         GError **error);

file :

input GFile.

result :

error :

Returns :


g_file_unmount_mountable ()

void                g_file_unmount_mountable            (GFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

file :

input GFile.

cancellable :

GCancellable interrupt object.

callback :

user_data :


g_file_unmount_mountable_finish ()

gboolean            g_file_unmount_mountable_finish     (GFile *file,
                                                         GAsyncResult *result,
                                                         GError **error);

file :

input GFile.

result :

error :

Returns :


g_file_eject_mountable ()

void                g_file_eject_mountable              (GFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

file :

input GFile.

cancellable :

GCancellable interrupt object.

callback :

user_data :


g_file_eject_mountable_finish ()

gboolean            g_file_eject_mountable_finish       (GFile *file,
                                                         GAsyncResult *result,
                                                         GError **error);

file :

input GFile.

result :

error :

Returns :


g_file_monitor_directory ()

GDirectoryMonitor*  g_file_monitor_directory            (GFile *file,
                                                         GFileMonitorFlags flags,
                                                         GCancellable *cancellable);

file :

input GFile.

flags :

GFileMonitorFlags enum

cancellable :

GCancellable interrupt object.

Returns :

GDirectoryMonitor

g_file_monitor_file ()

GFileMonitor*       g_file_monitor_file                 (GFile *file,
                                                         GFileMonitorFlags flags,
                                                         GCancellable *cancellable);

file :

input GFile.

flags :

GFileMonitorFlags enum

cancellable :

GCancellable interrupt object.

Returns :

GFileMonitor

g_file_load_contents ()

gboolean            g_file_load_contents                (GFile *file,
                                                         GCancellable *cancellable,
                                                         char **contents,
                                                         gsize *length,
                                                         char **etag_out,
                                                         GError **error);

file :

input GFile.

cancellable :

GCancellable interrupt object.

contents :

length :

etag_out :

error :

Returns :


g_file_load_contents_async ()

void                g_file_load_contents_async          (GFile *file,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

file :

input GFile.

cancellable :

GCancellable interrupt object.

callback :

user_data :


g_file_load_contents_finish ()

gboolean            g_file_load_contents_finish         (GFile *file,
                                                         GAsyncResult *res,
                                                         char **contents,
                                                         gsize *length,
                                                         char **etag_out,
                                                         GError **error);

file :

input GFile.

res :

contents :

length :

etag_out :

error :

Returns :


g_file_load_partial_contents_async ()

void                g_file_load_partial_contents_async  (GFile *file,
                                                         GCancellable *cancellable,
                                                         GFileReadMoreCallback read_more_callback,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

file :

input GFile.

cancellable :

GCancellable interrupt object.

read_more_callback :

callback :

user_data :


g_file_load_partial_contents_finish ()

gboolean            g_file_load_partial_contents_finish (GFile *file,
                                                         GAsyncResult *res,
                                                         char **contents,
                                                         gsize *length,
                                                         char **etag_out,
                                                         GError **error);

file :

input GFile.

res :

contents :

length :

etag_out :

error :

Returns :


g_file_replace_contents ()

gboolean            g_file_replace_contents             (GFile *file,
                                                         const char *contents,
                                                         gsize length,
                                                         const char *etag,
                                                         gboolean make_backup,
                                                         GFileCreateFlags flags,
                                                         char **new_etag,
                                                         GCancellable *cancellable,
                                                         GError **error);

file :

input GFile.

contents :

length :

etag :

make_backup :

flags :

new_etag :

cancellable :

GCancellable interrupt object.

error :

Returns :

TRUE if successful, FALSE on error.

g_file_replace_contents_async ()

void                g_file_replace_contents_async       (GFile *file,
                                                         const char *contents,
                                                         gsize length,
                                                         const char *etag,
                                                         gboolean make_backup,
                                                         GFileCreateFlags flags,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

file :

input GFile.

contents :

string of contents to add to the file.

length :

length of the contents string.

etag :

make_backup :

gboolean to indicate if a backup of the file should be made.

flags :

GFileCreateFlags to set the mode.

cancellable :

GCancellable interrupt object.

callback :

user_data :


g_file_replace_contents_finish ()

gboolean            g_file_replace_contents_finish      (GFile *file,
                                                         GAsyncResult *res,
                                                         char **new_etag,
                                                         GError **error);

This function will take ownership of new_etag.

file :

input GFile.

res :

new_etag :

error :

Returns :

TRUE on success, FALSE on failure.