path: root/gio/src/file.hg

/* Copyright (C) 2007 The gtkmm Development Team
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <glibmm/error.h>
#include <glibmm/interface.h>
#include <giomm/appinfo.h>
#include <giomm/asyncresult.h>
#include <giomm/fileattributeinfolist.h>
#include <giomm/fileenumerator.h>
#include <giomm/fileinfo.h>
#include <giomm/fileinputstream.h>
#include <giomm/fileiostream.h>
#include <giomm/filemonitor.h>
#include <giomm/fileoutputstream.h>
#include <giomm/mountoperation.h>
#include <giomm/drive.h>
#include <giomm/error.h> //Because this is thrown by some of these methods.
#include <utility>

_DEFS(giomm,gio)
_PINCLUDE(glibmm/private/interface_p.h)

#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GFileIface GFileIface;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

namespace Gio
{

class GIOMM_API Mount;
class GIOMM_API Volume;

_WRAP_ENUM(FileQueryInfoFlags, GFileQueryInfoFlags, NO_GTYPE, decl_prefix GIOMM_API)
_WRAP_ENUM(FileMonitorFlags, GFileMonitorFlags, NO_GTYPE, decl_prefix GIOMM_API)


/** %File and directory handling.
 * %Gio::File is a high level abstraction for manipulating files on a virtual file system. Gio::Files are lightweight, immutable objects that do no
 * I/O upon creation. It is necessary to understand that a %Gio::File object does not represent a file, merely a handle to a file. All file I/O is
 * implemented as streaming operations (see Gio::InputStream and Gio::OutputStream).
 *
 * A %Gio::File can be constructed from a path, URI, or a command line argument.
 *
 * You can move through the filesystem with %Gio::File handles with get_parent() to get a handle to the parent directory,
 * get_child() to get a handle to a child within a directory, and resolve_relative_path() to resolve a relative path between two Gio::Files.
 *
 * Many %Gio::File operations have both synchronous and asynchronous versions to suit your application. Asynchronous versions of synchronous
 * functions simply have _async() appended to their function names. The asynchronous I/O functions call a SlotAsyncReady callback slot which is
 * then used to finalize the operation, producing a AsyncResult which is then passed to the function's matching _finish() operation.
 *
 * Some %Gio::File operations do not have synchronous analogs, as they may take a very long time to finish, and blocking may leave an application
 * unusable. Notable cases include: mount_mountable() to mount a mountable file, unmount_mountable() to unmount a mountable file,
 * and eject_mountable() to eject a mountable file.
 *
 * One notable feature of Gio::Files are entity tags, or "etags" for short. Entity tags are somewhat like a more abstract version of the
 * traditional mtime, and can be used to quickly determine if the file has been modified from the version on the file system.
 * See the HTTP 1.1 specification for HTTP Etag headers, which are a very similar concept.
 *
 * @newin{2,16}
 */
class File : public Glib::Interface
{
  _CLASS_INTERFACE(File, GFile, G_FILE, GFileIface, , , GIOMM_API)

public:
  _WRAP_ENUM(CreateFlags, GFileCreateFlags, NO_GTYPE, decl_prefix GIOMM_API)
  _WRAP_ENUM(CopyFlags, GFileCopyFlags, NO_GTYPE, decl_prefix GIOMM_API)
  _WRAP_ENUM(MeasureFlags, GFileMeasureFlags, NO_GTYPE, decl_prefix GIOMM_API)

  _IGNORE(g_file_icon_new) //g_file_icon_new is not a GFile method.

  // Although this is an interface, it is possible to create objects using
  // its static create* members. In the implementation, these would lead
  // to functions of the default GVfs implementation, which, in case of
  // this class' create methods, would rely on concrete GFile implementations
  // such as GLocalFile and GDummyFile.

  /** Constructs a File for a given path.
   * This operation never fails, but the returned object might not support any I/O operation if path is malformed.
   *
   * @param path A string containing a relative or absolute path.
   * @result A new instantiation of an appropriate Gio::File class.
   */
  static Glib::RefPtr<File> create_for_path(const std::string& path);
  _IGNORE(g_file_new_for_path)

  /** Constructs a File for a given URI.
   * This operation never fails, but the returned object might not support any I/O operation if path is malformed.
   *
   * @param uri A string containing a URI.
   * @result A new instantiation of an appropriate Gio::File class.
   */
  static Glib::RefPtr<File> create_for_uri(const std::string& uri);
  _IGNORE(g_file_new_for_uri)

  /** Constructs a File for a given argument from the command line.
   * The value of @a arg can be either a URI, an absolute path or a relative path resolved relative to the current working directory.
   * This operation never fails, but the returned object might not support any I/O operation if arg points to a malformed path.
   *
   * @param arg A string containing a relative or absolute path.
   * @result A new instantiation of an appropriate Gio::File class.
   */
  static Glib::RefPtr<File> create_for_commandline_arg(const std::string& arg);
  _IGNORE(g_file_new_for_commandline_arg)

  /** Constructs a file in the preferred directory for temporary files.
   *
   * The file is created in the directory returned by Glib::get_tmp_dir().
   * A FileIOStream pointing to the file is also created.
   *
   * @a tmpl should be a string in the GLib file name encoding
   * containing a sequence of six 'X' characters, and containing no
   * directory components. If it is an empty string, a default template is used.
   *
   * Unlike the other %File constructors, this will throw an exception if
   * a temporary file could not be created.
   *
   * @newin{2,74}
   *
   * @param tmpl Template for the file name, as in Glib::file_open_tmp(),
   *             or an empty string for a default template.
   * @return {file, iostream} A new %File and a FileIOStream for the created file.
   *
   * @throws Glib::FileError
   */
  static std::pair<Glib::RefPtr<File>, Glib::RefPtr<FileIOStream>> create_tmp(const std::string& tmpl = {});
  _IGNORE(g_file_new_tmp)

  // parse_name is a UTF8-guaranteed "nice" string that can both
  // be resolved to a GFile (via create_for_parse_name) and put in
  // e.g. a GtkEntry. In practice, it is either a UTF8-only absolute
  // filename (if it starts with a /), or an IRI (i.e. a URI that allows
  // UTF8-encoded unicode chars instead of escaping them).
  /** Constructs a %File with the given @a parse_name.
   *
   * The @a parse_name is something given by get_parse_name().
   * This operation never fails, but the returned object might not support any
   * I/O operation if the @a parse_name cannot be parsed.
   *
   * @param parse_name A UTF-8 encoded file name or path to be parsed.
   * @return A new %File.
   */
  static Glib::RefPtr<File> create_for_parse_name(const Glib::ustring& parse_name);
  _IGNORE(g_file_parse_name)

  _WRAP_METHOD(Glib::RefPtr<File> dup() const, g_file_dup)

  // The method intended to be used for making hash tables
  // (g_hash_table_new in C).
  _WRAP_METHOD(guint hash() const, g_file_hash)

  //Note that the implementation of equal() is already virtual via equal_vfunc().
  /** Checks equality of two given Files.
   *
   * Note that two Files that differ can still refer to the same
   * file on the filesystem due to various forms of filename
   * aliasing.
   *
   * This call does no blocking I/O.
   * @param other The other File.
   * @return <tt>true</tt> if @a *this and @a other are equal.
   * <tt>false</tt> if either is not a File.
   */
  _WRAP_METHOD(bool equal(const Glib::RefPtr<const File>& other) const, g_file_equal)

  _WRAP_METHOD(std::string get_basename() const, g_file_get_basename)
  _WRAP_METHOD(std::string get_path() const, g_file_get_path)
  _IGNORE(g_file_peek_path)
  _WRAP_METHOD(std::string get_uri() const, g_file_get_uri)
  _WRAP_METHOD(Glib::ustring get_parse_name() const, g_file_get_parse_name)

  //Note that these return a reference (usually new instances),
  //so we don't need to use refreturn.

  //TODO: Do we need const and unconst versions of these get_*() methods,
  //or do we consider that the returned File cannot be used to change "this".
  //murrayc.
  _WRAP_METHOD(Glib::RefPtr<File> get_parent() const,
               g_file_get_parent)

  _WRAP_METHOD(bool has_parent(const Glib::RefPtr<File>& parent) const,
               g_file_has_parent)

  /** Checks if the file has any parent at all.
   * @result true if the file is a child of any parent.
   *
   * @newin{2,24}
   */
  bool has_parent() const;

  _WRAP_METHOD(Glib::RefPtr<File> get_child(const std::string& name) const,
               g_file_get_child)

  _WRAP_METHOD(Glib::RefPtr<File> get_child_for_display_name(const Glib::ustring& display_name) const,
               g_file_get_child_for_display_name,
               errthrow)

  _WRAP_METHOD(bool has_prefix(const Glib::RefPtr<const File>& prefix) const,
               g_file_has_prefix)
  _WRAP_METHOD(std::string get_relative_path(const Glib::RefPtr<const File>& descendant) const,
               g_file_get_relative_path)
  _WRAP_METHOD(Glib::RefPtr<File> resolve_relative_path(const std::string& relative_path) const,
               g_file_resolve_relative_path)
  _WRAP_METHOD(bool is_native() const, g_file_is_native)
  _WRAP_METHOD(bool has_uri_scheme(const std::string& uri_scheme) const,
               g_file_has_uri_scheme)

  _WRAP_METHOD(std::string get_uri_scheme() const, g_file_get_uri_scheme)

  //TODO: We don't have both const and unconst versions because a FileInputStream can't really change the File.
  _WRAP_METHOD(Glib::RefPtr<FileInputStream> read(const Glib::RefPtr<Cancellable>& cancellable{?}),
               g_file_read,
               errthrow)

  /** Asynchronously opens the file for reading.
   * For more details, see read() which is the synchronous version of this call.
   * When the operation is finished, @a slot will be called. You can then call read_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param io_priority The I/O priority of the request.
   */
  void read_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, int io_priority = Glib::PRIORITY_DEFAULT);

  /** Asynchronously opens the file for reading.
   * For more details, see read() which is the synchronous version of this call.
   * When the operation is finished, @a slot will be called. You can then call read_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param io_priority The I/O priority of the request.
   */
  void read_async(const SlotAsyncReady& slot, int io_priority = Glib::PRIORITY_DEFAULT);
  _IGNORE(g_file_read_async)

  _WRAP_METHOD(Glib::RefPtr<FileInputStream> read_finish(const Glib::RefPtr<AsyncResult>& res),
               g_file_read_finish,
               errthrow)


  /** 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 CreateFlags::PRIVATE in @a flags the file
   * will be made readable only to the current user, to the level that
   * is supported on the target filesystem.
   *
   * The operation can be cancelled by
   * triggering the cancellable object from another thread. If the operation
   * was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * Some filesystems don't allow all filenames, and may
   * throw a Gio::Error with INVALID_FILENAME.
   * If the file is a directory a Gio::Error with IS_DIRECTORY will be
   * thrown. Other errors are possible too, and depend on what kind of
   * filesystem the file is on.
   * @param flags A set of CreateFlags.
   * @param cancellable Optional Cancellable object.
   * @return A FileOutputStream.
   */
  Glib::RefPtr<FileOutputStream> append_to(const Glib::RefPtr<Cancellable>& cancellable, CreateFlags flags = CreateFlags::NONE);

  /** 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 CreateFlags::PRIVATE in @a flags the file
   * will be made readable only to the current user, to the level that
   * is supported on the target filesystem.
   *
   * Some filesystems don't allow all filenames, and may
   * throw a Gio::Error with INVALID_FILENAME.
   * If the file is a directory a Gio::Error with IS_DIRECTORY will be
   * thrown. Other errors are possible too, and depend on what kind of
   * filesystem the file is on.
   * @param flags A set of CreateFlags.
   * @return A FileOutputStream.
   */
  Glib::RefPtr<FileOutputStream> append_to(CreateFlags flags = CreateFlags::NONE);
  _IGNORE(g_file_append_to)

  //We renamed this to create_file from (g_file_create() and g_file_create_readwrite), to avoid confusion with static create() methods,
  //but I would still like to choose a different word, but can't think of a good one. murrayc.

  /** 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 CreateFlags::PRIVATE in @a flags the file
   * will be made readable only to the current user, to the level that
   * is supported on the target filesystem.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread.
   * If the operation was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * If a file with this name already exists a Gio::Error with EXISTS
   * will be thrown. If the file is a directory a Gio::Error with IS_DIRECTORY
   * will be thrown.
   *
   * Some filesystems don't allow all filenames, and may
   * throw a Gio::Error with INVALID_FILENAME, and if the name
   * is to longa Gio::Error with FILENAME_TOO_LONG will be thrown.
   * Other errors are possible too, and depend on what kind of
   * filesystem the file is on.
   *
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param flags a set of CreateFlags.
   * @return A FileOutputStream for the newly created file.
   */
  Glib::RefPtr<FileOutputStream> create_file(const Glib::RefPtr<Cancellable>& cancellable, CreateFlags flags = CreateFlags::NONE);

  /** 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 CreateFlags::PRIVATE in @a flags the file
   * will be made readable only to the current user, to the level that
   * is supported on the target filesystem.
   *
   * If a file with this name already exists a Gio::Error with EXISTS
   * will be thrown. If the file is a directory a Gio::Error with IS_DIRECTORY
   * will be thrown.
   *
   * Some filesystems don't allow all filenames, and may
   * throw a Gio::Error with INVALID_FILENAME, and if the name
   * is to longa Gio::Error with FILENAME_TOO_LONG will be thrown.
   * Other errors are possible too, and depend on what kind of
   * filesystem the file is on.
   *
   * @param flags a set of CreateFlags.
   * @return A FileOutputStream for the newly created file.
   */
  Glib::RefPtr<FileOutputStream> create_file(CreateFlags flags = CreateFlags::NONE);
  _IGNORE(g_file_create)

  /** 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 CreateFlags::PRIVATE in @a flags the file
   * will be made readable only to the current user, to the level that
   * is supported on the target filesystem.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread.
   * If the operation was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * If a file with this name already exists a Gio::Error with EXISTS
   * will be thrown. If the file is a directory a Gio::Error with IS_DIRECTORY
   * will be thrown.
   *
   * Some filesystems don't allow all filenames, and may
   * throw a Gio::Error with INVALID_FILENAME, and if the name
   * is to longa Gio::Error with FILENAME_TOO_LONG will be thrown.
   * 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.
   *
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param flags a set of CreateFlags.
   * @return A FileOutputStream for the newly created file.
   */
  Glib::RefPtr<FileIOStream> create_file_readwrite(const Glib::RefPtr<Cancellable>& cancellable, CreateFlags flags = CreateFlags::NONE);

  /** 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 CreateFlags::PRIVATE in @a flags the file
   * will be made readable only to the current user, to the level that
   * is supported on the target filesystem.
   *
   * If a file with this name already exists a Gio::Error with EXISTS
   * will be thrown. If the file is a directory a Gio::Error with IS_DIRECTORY
   * will be thrown.
   *
   * Some filesystems don't allow all filenames, and may
   * throw a Gio::Error with INVALID_FILENAME, and if the name
   * is to longa Gio::Error with FILENAME_TOO_LONG will be thrown.
   * 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.
   *
   * @param flags a set of CreateFlags.
   * @return A FileOutputStream for the newly created file.
   */
  Glib::RefPtr<FileIOStream> create_file_readwrite(CreateFlags flags = CreateFlags::NONE);
  _IGNORE(g_file_create_readwrite)



  /** Returns an output stream for overwriting the file, possibly creating a backup copy of the file first.
   * 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 CreateFlags::PRIVATE in
   * @a flags the file will be made readable only to the current user, to the level that is supported on the
   * target filesystem.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread.
   * If the operation was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * If you pass in an etag value, then this value is compared to the current entity tag of the file,
   * and if they differ a Gio::Error with WRONG_ETAG will be thrown. This generally means that the file has
   * been changed since you last read it. You can get the new etag from FileOutputStream::get_etag()
   * after you've finished writing and closed the FileOutputStream. When you load a new file you can
   * use FileInputStream::query_info() to get the etag of the file.
   *
   * If @a make_backup is true, this function will attempt to make a backup of the current file before
   * overwriting it. If this fails aa Gio::Error with CANT_CREATE_BACKUP will be thrown. If you want to replace
   * anyway, try again with @a make_backup set to false.
   *
   * If the file is a directory a Gio::Error with IS_DIRECTORY will be thrown, and if the file is some
   * other form of non-regular file then aa Gio::Error with NOT_REGULAR_FILE will be thrown. Some file
   * systems don't allow all file names, and may throw a Gio::Error with INVALID_FILENAME, and if the
   * name is to longa Gio::Error with FILENAME_TOO_LONG will be thrown. Other errors are possible too, and
   * depend on what kind of filesystem the file is on.
   *
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param etag An optional entity tag for the current Glib::File.
   * @param make_backup <tt>true</tt> if a backup should be created.
   * @param flags A set of CreateFlags.
   * @return A FileOutputStream.
   */
  Glib::RefPtr<FileOutputStream> replace(const Glib::RefPtr<Cancellable>& cancellable, const std::string& etag = {}, bool make_backup = false, CreateFlags flags = CreateFlags::NONE);


  /** Returns an output stream for overwriting the file, possibly creating a backup copy of the file first.
   * 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 CreateFlags::PRIVATE in
   * @a flags the file will be made readable only to the current user, to the level that is supported on the
   * target filesystem.
   *
   * If you pass in an etag value, then this value is compared to the current entity tag of the file,
   * and if they differ a Gio::Error with WRONG_ETAG will be thrown. This generally means that the file has
   * been changed since you last read it. You can get the new etag from FileOutputStream::get_etag()
   * after you've finished writing and closed the FileOutputStream. When you load a new file you can
   * use FileInputStream::query_info() to get the etag of the file.
   *
   * If @a make_backup is true, this function will attempt to make a backup of the current file before
   * overwriting it. If this fails aa Gio::Error with CANT_CREATE_BACKUP will be thrown. If you want to replace
   * anyway, try again with @a make_backup set to false.
   *
   * If the file is a directory a Gio::Error with IS_DIRECTORY will be thrown, and if the file is some
   * other form of non-regular file then aa Gio::Error with NOT_REGULAR_FILE will be thrown. Some file
   * systems don't allow all file names, and may throw a Gio::Error with INVALID_FILENAME, and if the
   * name is to longa Gio::Error with FILENAME_TOO_LONG will be thrown. Other errors are possible too, and
   * depend on what kind of filesystem the file is on.
   *
   * @param etag An optional entity tag for the current Glib::File.
   * @param make_backup <tt>true</tt> if a backup should be created.
   * @param flags A set of CreateFlags.
   * @return A FileOutputStream.
   */
  Glib::RefPtr<FileOutputStream> replace(const std::string& etag = {}, bool make_backup = false, CreateFlags flags = CreateFlags::NONE);

  _IGNORE(g_file_replace)


  /** Asynchronously opens the file for appending.
   * For more details, see append_to() which is the synchronous version of this call.
   *
   * When the operation is finished, @a slot will be called. You can then call append_to_finish() to get the result of the operation.
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param flags a set of CreateFlags.
   * @param io_priority The I/O priority of the request.
   */
  void append_to_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, CreateFlags flags = CreateFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);

  /** Asynchronously opens the file for appending.
   * For more details, see append_to() which is the synchronous version of this call.
   *
   * When the operation is finished, @a slot will be called. You can then call append_to_finish() to get the result of the operation.
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param flags a set of CreateFlags.
   * @param io_priority The I/O priority of the request.
   */
  void append_to_async(const SlotAsyncReady& slot, CreateFlags flags = CreateFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);
  _IGNORE(g_file_append_to_async)

  _WRAP_METHOD(Glib::RefPtr<FileOutputStream> append_to_finish(const Glib::RefPtr<AsyncResult>& res),
               g_file_append_to_finish,
               errthrow)

  //We renamed this to create_file_async from (g_file_create_async() and g_file_create_readwrite_async), to avoid confusion with static create() methods,
  //but I would still like to choose a different word, but can't think of a good one. murrayc. See also create_file().

  /** Asynchronously creates a new file and returns an output stream for writing to it. The file must not already exist.
   * For more details, see create_file() which is the synchronous version of this call.
   *
   * When the operation is finished, @a slot will be called. You can then call create_file_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param flags a set of CreateFlags.
   * @param io_priority The I/O priority of the request.
   */
  void create_file_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, CreateFlags flags = CreateFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);

  /** Asynchronously creates a new file and returns an output stream for writing to it. The file must not already exist.
   * For more details, see create_file() which is the synchronous version of this call.
   *
   * When the operation is finished, @a slot will be called. You can then call create_file_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param flags a set of CreateFlags.
   * @param io_priority The I/O priority of the request.
   */
  void create_file_async(const SlotAsyncReady& slot, CreateFlags flags = CreateFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);
  _IGNORE(g_file_create_async)

  _WRAP_METHOD(Glib::RefPtr<FileOutputStream> create_file_finish(const Glib::RefPtr<AsyncResult>& res),
               g_file_create_finish,
               errthrow)


  /** 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 create_file_readwrite() which is the synchronous version of this call.
   *
   * When the operation is finished, @a slot will be called. You can then call create_file_readwrite_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param flags a set of CreateFlags.
   * @param io_priority The I/O priority of the request.
   *
   * @newin{2,24}
   */
  void create_file_readwrite_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, CreateFlags flags = CreateFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);

  /** 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 create_file_readwrite() which is the synchronous version of this call.
   *
   * When the operation is finished, @a slot will be called. You can then call create_file_readwrite_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param flags a set of CreateFlags.
   * @param io_priority The I/O priority of the request.
   *
   * @newin{2,24}
   */
  void create_file_readwrite_async(const SlotAsyncReady& slot, CreateFlags flags = CreateFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);
  _IGNORE(g_file_create_readwrite_async)

  _WRAP_METHOD(Glib::RefPtr<FileIOStream> create_file_readwrite_finish(const Glib::RefPtr<AsyncResult>& res),
               g_file_create_readwrite_finish,
               errthrow)

  /** Asyncronously overwrites the file, replacing the contents, possibly creating a backup copy of the file first.
   * For more details, see replace() which is the synchronous version of this call.
   * When the operation is finished, @a slot will be called. You can then call replace_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param etag An entity tag for the current Gio::File.
   * @param make_backup true if a backup of the existing file should be made.
   * @param flags A set of CreateFlags.
   * @param io_priority The I/O priority of the request.
   */
  void replace_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const std::string& etag = {}, bool make_backup = false, CreateFlags flags = CreateFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);

  /** Asyncronously overwrites the file, replacing the contents, possibly creating a backup copy of the file first.
   * For more details, see replace() which is the synchronous version of this call.
   * When the operation is finished, @a slot will be called. You can then call replace_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param etag An entity tag for the current Gio::File.
   * @param make_backup true if a backup of the existing file should be made.
   * @param flags A set of CreateFlags.
   * @param io_priority The I/O priority of the request.
   */
  void replace_async(const SlotAsyncReady& slot, const std::string& etag = {}, bool make_backup = false, CreateFlags flags = CreateFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);
  _IGNORE(g_file_replace_async)

  _WRAP_METHOD(Glib::RefPtr<FileOutputStream> replace_finish(const Glib::RefPtr<AsyncResult>& res),
               g_file_replace_finish,
               errthrow)

  _WRAP_METHOD(Glib::RefPtr<FileIOStream> open_readwrite(const Glib::RefPtr<Cancellable>& cancellable{?}),
               g_file_open_readwrite,
               errthrow)

  /** Opens an existing file for reading and writing.
   * The result is a FileIOStream that can be used to read and write the contents of the file.
   *
   * For more details, see open_readwrite() which is the synchronous version of this call.
   * When the operation is finished, @a slot will be called. You can then call open_readwrite_finish() to get the result of the operation.
   * If the file does not exist, a Gio::Error with NOT_FOUND will be thrown.
   * If the file is a directory, a Gio::Error with IS_DIRECTORY will be thrown.
   * 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.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param io_priority The I/O priority of the request.
   *
   * @newin{2,24}
   */
  void open_readwrite_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, int io_priority = Glib::PRIORITY_DEFAULT);

  /** Opens an existing file for reading and writing.
   * The result is a FileIOStream that can be used to read and write the contents of the file.
   *
   * For more details, see open_readwrite() which is the synchronous version of this call.
   * When the operation is finished, @a slot will be called. You can then call open_readwrite_finish() to get the result of the operation.
   * If the file does not exist, a Gio::Error with NOT_FOUND will be thrown.
   * If the file is a directory, a Gio::Error with IS_DIRECTORY will be thrown.
   * 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.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param io_priority The I/O priority of the request.
   *
   * @newin{2,24}
   */
  void open_readwrite_async(const SlotAsyncReady& slot, int io_priority = Glib::PRIORITY_DEFAULT);
  _IGNORE(g_file_open_readwrite_async)

  _WRAP_METHOD(Glib::RefPtr<FileIOStream> open_readwrite_finish(const Glib::RefPtr<AsyncResult>& res),
               g_file_open_readwrite_finish,
               errthrow)

  /** Returns an output stream for overwriting the file in readwrite mode, possibly creating a backup copy of the file first.
   *
   * If the file doesn't exist, it will be created.
   *
   * For details about the behaviour, see replace() which does the same thing but returns an output stream only.
   *
   * Note that in many non-local file cases read and write streams are not supported,
   * so make sure you really need to do read and write streaming,
   * rather than just opening for reading or writing.
   *
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param etag An optional entity tag for the current Glib::File.
   * @param make_backup <tt>true</tt> if a backup should be created.
   * @param flags A set of CreateFlags.
   * @return A FileOutputStream.
   *
   * @newin{2,24}
   */
  Glib::RefPtr<FileIOStream> replace_readwrite(const Glib::RefPtr<Cancellable>& cancellable, const std::string& etag = {}, bool make_backup = false, CreateFlags flags = CreateFlags::NONE);


  /** Returns an output stream for overwriting the file in readwrite mode, possibly creating a backup copy of the file first.
   *
   * If the file doesn't exist, it will be created.
   *
   * For details about the behaviour, see replace() which does the same thing but returns an output stream only.
   *
   * Note that in many non-local file cases read and write streams are not supported,
   * so make sure you really need to do read and write streaming,
   * rather than just opening for reading or writing.
   *
   * @param etag An optional entity tag for the current Glib::File.
   * @param make_backup <tt>true</tt> if a backup should be created.
   * @param flags A set of CreateFlags.
   * @return A FileOutputStream.
   *
   * @newin{2,24}
   */
  Glib::RefPtr<FileIOStream> replace_readwrite(const std::string& etag = {}, bool make_backup = false, CreateFlags flags = CreateFlags::NONE);

  _IGNORE(g_file_replace_readwrite)


  /** Asyncronously overwrites the file in read-write mode, replacing the contents, possibly creating a backup copy of the file first.
   *
   * For more details, see replace_readwrite() which is the synchronous version of this call.
   *
   * When the operation is finished, @a slot will be called. You can then call replace_readwrite_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param etag An entity tag for the current Gio::File.
   * @param make_backup true if a backup of the existing file should be made.
   * @param flags A set of CreateFlags.
   * @param io_priority The I/O priority of the request.
   *
   * @newin{2,24}
   */
  void replace_readwrite_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const std::string& etag = {}, bool make_backup = false, CreateFlags flags = CreateFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);

  /** Asyncronously overwrites the file in read-write mode, replacing the contents, possibly creating a backup copy of the file first.
   *
   * For more details, see replace_readwrite() which is the synchronous version of this call.
   * When the operation is finished, @a slot will be called. You can then call replace_readwrite_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param etag An entity tag for the current Gio::File.
   * @param make_backup true if a backup of the existing file should be made.
   * @param flags A set of CreateFlags.
   * @param io_priority The I/O priority of the request.
   *
   * @newin{2,24}
   */
  void replace_readwrite_async(const SlotAsyncReady& slot, const std::string& etag = {}, bool make_backup = false, CreateFlags flags = CreateFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);
  _IGNORE(g_file_replace_readwrite_async)

  _WRAP_METHOD(Glib::RefPtr<FileIOStream> replace_readwrite_finish(const Glib::RefPtr<AsyncResult>& res),
               g_file_replace_readwrite_finish,
               errthrow)

  /** Gets the requested information about the file. The result
   * is a FileInfo object that contains key-value attributes (such as the  type or size
   * of the file).
   *
   * The @a attribute 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. @a attribute should
   * be a comma-separated list of attribute or attribute wildcards. The wildcard "*"
   * means all attributes, and a wildcard like "standard::*" means all attributes in the standard
   * namespace. An example attribute query be "standard::*,owner::user".
   * The standard attributes are available as defines, like G_FILE_ATTRIBUTE_STANDARD_NAME.
   *
   * The operation can be cancelled by
   * triggering the cancellable object from another thread. If the operation
   * was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * For symlinks, normally the information about the target of the
   * symlink is returned, rather than information about the symlink itself.
   * However if you pass FileQueryInfoFlags::NOFOLLOW_SYMLINKS in @a 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, a Gio::Error with NOT_FOUND will be thrown.
   * Other errors are possible too, and depend on what kind of filesystem the file is on.
   *
   * @param cancellable A Cancellable object.
   * @param attributes: An attribute query string.
   * @param flags: A set of FileQueryInfoFlags.
   * @result a FileInfo for the file, or an empty RefPtr on error.
   */
  Glib::RefPtr<FileInfo> query_info(const Glib::RefPtr<Cancellable>& cancellable, const std::string& attributes = "*", FileQueryInfoFlags flags = FileQueryInfoFlags::NONE) const;

  /** Gets the requested information about the file. The result
   * is a FileInfo object that contains key-value attributes (such as the  type or size
   * of the file).
   *
   * The @a attribute 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. @a attribute should
   * be a comma-separated list of attribute or attribute wildcards. The wildcard "*"
   * means all attributes, and a wildcard like "standard::*" means all attributes in the standard
   * namespace. An example attribute query be "standard::*,owner::user".
   * The standard attributes are available as defines, like G_FILE_ATTRIBUTE_STANDARD_NAME.
   *
   * For symlinks, normally the information about the target of the
   * symlink is returned, rather than information about the symlink itself.
   * However if you pass FileQueryInfoFlags::NOFOLLOW_SYMLINKS in @a 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, a Gio::Error with NOT_FOUND will be thrown.
   * Other errors are possible too, and depend on what kind of filesystem the file is on.
   *
   * @param attributes: An attribute query string.
   * @param flags: A set of FileQueryInfoFlags.
   * @result a FileInfo for the file, or an empty RefPtr on error.
   */
  Glib::RefPtr<FileInfo> query_info(const std::string& attributes = "*", FileQueryInfoFlags flags = FileQueryInfoFlags::NONE) const;

  _IGNORE(g_file_query_info)

  _WRAP_METHOD(bool query_exists(const Glib::RefPtr<Cancellable>& cancellable{?}) const, g_file_query_exists)

  //We cannot use the {?} format here because we want a default value for flags, but gmmproc then generates a method with a default value for flags when it is not the last parameter.
  _WRAP_METHOD(FileType query_file_type(FileQueryInfoFlags flags, const Glib::RefPtr<Cancellable>& cancellable) const, g_file_query_file_type)

  /** Utility function to inspect the FileType of a file. This is
   * implemented using query_info() and as such does blocking I/O.
   *
   * The primary use case of this method is to check if a file is a regular file,
   * directory, or symlink.
   *
   * @param flags: a set of FileQueryInfoFlags passed to query_info().
   * @result The FileType of the file, or FILE_TYPE_UNKNOWN if the file does not exist.
   *
   * @newin{2,18}
   */
   FileType query_file_type(FileQueryInfoFlags flags = FileQueryInfoFlags::NONE) const;

  /** Asynchronously gets the requested information about specified file. The result is a FileInfo object that contains key-value attributes (such as type or size for the file).
   *
   * For more details, see query_info() which is the synchronous version of this call.
   * When the operation is finished, @a slot will be called. You can then call query_info_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param attributes An attribute query string.
   * @param flags A set of FileQueryInfoFlags.
   * @param io_priority The I/O priority of the request.
   */
  void query_info_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const std::string& attributes = "*", FileQueryInfoFlags flags = FileQueryInfoFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT) const;

  /** Asynchronously gets the requested information about specified file. The result is a FileInfo object that contains key-value attributes (such as type or size for the file).
   *
   * For more details, see query_info() which is the synchronous version of this call.
   * When the operation is finished, @a slot will be called. You can then call query_info_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param attributes An attribute query string.
   * @param flags A set of FileQueryInfoFlags.
   * @param io_priority The I/O priority of the request.
   */
  void query_info_async(const SlotAsyncReady& slot, const std::string& attributes = "*", FileQueryInfoFlags flags = FileQueryInfoFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT) const;
  _IGNORE(g_file_query_info_async)


  _WRAP_METHOD(Glib::RefPtr<FileInfo> query_info_finish(const Glib::RefPtr<AsyncResult>& res),
               g_file_query_info_finish,
               errthrow)

  /** Similar to query_info(), but obtains information
   * about the filesystem the file is on, rather than the file itself.
   * For instance the amount of space availible and the type of
   * the filesystem.
   *
   * The @a attribute  value is a string that specifies the file attributes that
   * should be gathered. It is not an error if its not possible to read a particular
   * requested attribute from a file, it just won't be set. @a attribute  should
   * be a comma-separated list of attribute or attribute wildcards. The wildcard "*"
   * means all attributes, and a wildcard like "fs:*" means all attributes in the fs
   * namespace. The standard namespace for filesystem attributes is "fs".
   * Common attributes of interest are FILE_ATTRIBUTE_FILESYSTEM_SIZE
   * (the total size of the filesystem in bytes), FILE_ATTRIBUTE_FILESYSTEM_FREE (number of
   * bytes availible), and FILE_ATTRIBUTE_FILESYSTEM_TYPE (type of the filesystem).
   *
   * The operation can be cancelled by
   * triggering the cancellable object from another thread. If the operation
   * was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * If the file does not exist, a Gio::Error with NOT_FOUND will be thrown.
   * Other errors are possible too, and depend on what kind of filesystem the file is on.
   * @param cancellable A Cancellable object.
   * @param attributes An attribute query string.
   * @return A FileInfo or an empty RefPtr if there was an error.
   */
  Glib::RefPtr<FileInfo> query_filesystem_info(const Glib::RefPtr<Cancellable>& cancellable, const std::string& attributes = "*");

  /** Similar to query_info(), but obtains information
   * about the filesystem the file is on, rather than the file itself.
   * For instance the amount of space availible and the type of
   * the filesystem.
   *
   * The @a attribute  value is a string that specifies the file attributes that
   * should be gathered. It is not an error if its not possible to read a particular
   * requested attribute from a file, it just won't be set. @a attribute  should
   * be a comma-separated list of attribute or attribute wildcards. The wildcard "*"
   * means all attributes, and a wildcard like "fs:*" means all attributes in the fs
   * namespace. The standard namespace for filesystem attributes is "fs".
   * Common attributes of interest are FILE_ATTRIBUTE_FILESYSTEM_SIZE
   * (the total size of the filesystem in bytes), FILE_ATTRIBUTE_FILESYSTEM_FREE (number of
   * bytes availible), and FILE_ATTRIBUTE_FILESYSTEM_TYPE (type of the filesystem).
   *
   *
   * If the file does not exist, a Gio::Error with NOT_FOUND will be thrown.
   * Other errors are possible too, and depend on what kind of filesystem the file is on.
   * @param attributes An attribute query string.
   * @return A FileInfo or an empty RefPtr if there was an error.
   */
  Glib::RefPtr<FileInfo> query_filesystem_info(const std::string& attributes = "*");
  _IGNORE(g_file_query_filesystem_info)

  _WRAP_METHOD(Glib::RefPtr<Mount> find_enclosing_mount(const Glib::RefPtr<Cancellable>& cancellable{?}),
               g_file_find_enclosing_mount, errthrow)

  /** Asynchronously gets the requested information about the filesystem
   * that the file is on. The result is a FileInfo object
   * that contains key-value attributes (such as type or size for the
   * file).
   *
   * For more details, see query_filesystem_info() which is the synchronous version of this call.
   *
   * When the operation is finished, @a slot will be called. You can then call query_filesystem_info_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param attributes An attribute query string.
   * @param io_priority The I/O priority of the request.
   */
  void query_filesystem_info_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const std::string& attributes = "*", int io_priority = Glib::PRIORITY_DEFAULT) const;

  /** Asynchronously gets the requested information about the filesystem
   * that the file is on. The result is a FileInfo object
   * that contains key-value attributes (such as type or size for the
   * file).
   *
   * For more details, see query_filesystem_info() which is the synchronous version of this call.
   *
   * When the operation is finished, @a slot will be called. You can then call query_filesystem_info_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param attributes An attribute query string.
   * @param io_priority The I/O priority of the request.
   */
  void query_filesystem_info_async(const SlotAsyncReady& slot, const std::string& attributes = "*", int io_priority = Glib::PRIORITY_DEFAULT) const;
  _IGNORE(g_file_query_filesystem_info_async)

  _WRAP_METHOD(Glib::RefPtr<FileInfo> query_filesystem_info_finish(const Glib::RefPtr<AsyncResult>& res),
               g_file_query_filesystem_info_finish,
               errthrow)

  /** Asynchronously gets the mount for the file.
   *
   * For more details, see find_enclosing_mount() which is
   * the synchronous version of this call.
   *
   * When the operation is finished, @a slot will be called. You can then call
   * find_enclosing_mount_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object.
   * @param io_priority The I/O priority of the request.
   */
  void find_enclosing_mount_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, int io_priority = Glib::PRIORITY_DEFAULT);

  /** Asynchronously gets the mount for the file.
   *
   * For more details, see find_enclosing_mount() which is
   * the synchronous version of this call.
   *
   * When the operation is finished, @a slot will be called. You can then call
   * find_enclosing_mount_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param io_priority The I/O priority of the request.
   */
  void find_enclosing_mount_async(const SlotAsyncReady& slot, int io_priority = Glib::PRIORITY_DEFAULT);
  _IGNORE(g_file_find_enclosing_mount_async)

  _WRAP_METHOD(Glib::RefPtr<Mount> find_enclosing_mount_finish(const Glib::RefPtr<AsyncResult>& res),
               g_file_find_enclosing_mount_finish, errthrow)

  /** 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 @a attribute  value is a string that specifies the file attributes that
   * should be gathered. It is not an error if its not possible to read a particular
   * requested attribute from a file, it just won't be set. @a attribute  should
   * be a comma-separated list of attribute 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 availible as defines, like FILE_ATTRIBUTE_STANDARD_NAME.
   *
   * The operation can be cancelled by
   * triggering the cancellable object from another thread. If the operation
   * was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * If the file does not exist, a Gio::Error with NOT_FOUND will be thrown.
   * If the file is not a directory, a Gio::Error with NOT_DIRECTORY will be thrown.
   * Other errors are possible too.
   *
   * @param cancellable A Cancellable object.
   * @param attributes An attribute query string.
   * @param flags A set of FileQueryInfoFlags.
   * @return A FileEnumerator if successful.
   */
  Glib::RefPtr<FileEnumerator> enumerate_children(const Glib::RefPtr<Cancellable>& cancellable, const std::string& attributes = "*", FileQueryInfoFlags flags = FileQueryInfoFlags::NONE);
  _IGNORE(g_file_enumerate_children)

  /** 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 @a attribute  value is a string that specifies the file attributes that
   * should be gathered. It is not an error if its not possible to read a particular
   * requested attribute from a file, it just won't be set. @a attribute  should
   * be a comma-separated list of attribute 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 availible as defines, like FILE_ATTRIBUTE_STANDARD_NAME.
   *
   * If the file does not exist, a Gio::Error with NOT_FOUND will be thrown.
   * If the file is not a directory, a Gio::Error with NOT_DIRECTORY will be thrown.
   * Other errors are possible too.
   *
   * @param attributes An attribute query string.
   * @param flags A set of FileQueryInfoFlags.
   * @return A FileEnumerator if successful.
   */
  Glib::RefPtr<FileEnumerator> enumerate_children(const std::string& attributes = "*", FileQueryInfoFlags flags = FileQueryInfoFlags::NONE);
  _IGNORE(g_file_enumerate_children)



  /** Asynchronously gets the requested information about the files in a directory. The result is a GFileEnumerator object that will give out GFileInfo objects for all the files in the directory.
   *
   * For more details, see enumerate_children() which is the synchronous version of this call.
   * When the operation is finished, @a slot will be called. You can then call enumerate_children_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param attributes An attribute query string.
   * @param flags A set of FileQueryInfoFlags.
   * @param io_priority The I/O priority of the request.
   */
  void enumerate_children_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const std::string& attributes = "*", FileQueryInfoFlags flags = FileQueryInfoFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);

  /** Asynchronously gets the requested information about the files in a directory. The result is a GFileEnumerator object that will give out GFileInfo objects for all the files in the directory.
   *
   * For more details, see enumerate_children() which is the synchronous version of this call.
   * When the operation is finished, @a slot will be called. You can then call enumerate_children_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param attributes An attribute query string.
   * @param flags A set of FileQueryInfoFlags.
   * @param io_priority The I/O priority of the request.
   */
  void enumerate_children_async(const SlotAsyncReady& slot, const std::string& attributes = "*", FileQueryInfoFlags flags = FileQueryInfoFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);
  _IGNORE(g_file_enumerate_children_async)

  _WRAP_METHOD(Glib::RefPtr<FileEnumerator> enumerate_children_finish(const Glib::RefPtr<AsyncResult>& res),
               g_file_enumerate_children_finish,
               errthrow)

  _WRAP_METHOD(Glib::RefPtr<File> set_display_name(const Glib::ustring& display_name, const Glib::RefPtr<Cancellable>& cancellable{?}),
               g_file_set_display_name,
               errthrow)

  /** Asynchronously sets the display name for a given Gio::File. For the synchronous version of this function, see set_display_name().
   * When the operation is finished, @a slot will be called. You can then call set_display_name_finish() to get the result of the operation.
   *
   * @param display_name A string.
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param io_priority The I/O priority of the request.
   */
  void set_display_name_async(const Glib::ustring& display_name, const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, int io_priority = Glib::PRIORITY_DEFAULT);

  /** Asynchronously sets the display name for a given Gio::File. For the synchronous version of this function, see set_display_name().
   * When the operation is finished, @a slot will be called. You can then call set_display_name_finish() to get the result of the operation.
   *
   * @param display_name A string.
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param io_priority The I/O priority of the request.
   */
  void set_display_name_async(const Glib::ustring& display_name, const SlotAsyncReady& slot, int io_priority = Glib::PRIORITY_DEFAULT);
  _IGNORE(g_file_set_display_name_async)

  _WRAP_METHOD(Glib::RefPtr<File> set_display_name_finish(const Glib::RefPtr<AsyncResult>& res),
               g_file_set_display_name_finish,
               errthrow)

  //TODO: Remove the bool results from this and other methods that throw an exception.

  /** Deletes a file.
   * If the file is a directory, it will only be deleted if it is empty.
   * The operation can be cancelled by triggering the cancellable object from another thread.
   * If the operation was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @return <tt>true</tt> if the file was deleted. <tt>false</tt> otherwise.
   */
   _WRAP_METHOD(bool remove(const Glib::RefPtr<Cancellable>& cancellable{?}),
                g_file_delete,
                errthrow)

   /** 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().
    *
    * @param slot_ready A SlotAsyncReady to call when the request is satisfied
    * @param cancellable A Cancellable object which can be used to cancel the operation
    * @param io_priority The I/O priority of the request
    * @newin{2,34}
    */
  void remove_async(const SlotAsyncReady& slot_ready, const Glib::RefPtr<Cancellable>& cancellable, int io_priority = Glib::PRIORITY_DEFAULT);

   /** 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().
    *
    * @param slot_ready A SlotAsyncReady to call when the request is satisfied
    * @param io_priority The I/O priority of the request
    * @newin{2,34}
    */
  void remove_async(const SlotAsyncReady& slot_ready, int io_priority = Glib::PRIORITY_DEFAULT);
  _IGNORE(g_file_delete_async)

  _WRAP_METHOD(bool remove_finish(const Glib::RefPtr<AsyncResult>& result),
               g_file_delete_finish,
               errthrow)


  _WRAP_METHOD(bool trash(const Glib::RefPtr<Cancellable>& cancellable{?}),
               g_file_trash,
               errthrow)

   /** Asynchronously sends the file to the Trash location, if possible.
    *
    * @param slot_ready A SlotAsyncReady to call when the request is satisfied
    * @param cancellable A Cancellable object which can be used to cancel the operation
    * @param io_priority The I/O priority of the request
    * @newin{2,38}
    */
  void trash_async(const SlotAsyncReady& slot_ready, const Glib::RefPtr<Cancellable>& cancellable, int io_priority = Glib::PRIORITY_DEFAULT);

   /** Asynchronously sends the file to the Trash location, if possible.
    *
    * @param slot_ready A SlotAsyncReady to call when the request is satisfied
    * @param io_priority The I/O priority of the request
    * @newin{2,38}
    */
  void trash_async(const SlotAsyncReady& slot_ready, int io_priority = Glib::PRIORITY_DEFAULT);
  _IGNORE(g_file_trash_async)

  _WRAP_METHOD(bool trash_finish(const Glib::RefPtr<AsyncResult>& result),
               g_file_trash_finish,
               errthrow)


  /** A signal handler would be, for instance:
   * void on_file_progress(goffset current_num_bytes, goffset total_num_bytes);
   */
  using SlotFileProgress = sigc::slot<void(goffset, goffset)>;

  /** Copies the file source to the location specified by destination. Can not handle recursive copies of directories.
   * If the flag CopyFlags::OVERWRITE is specified an already existing destination file is overwritten.
   * If the flag CopyFlags::NOFOLLOW_SYMLINKS is specified then symlinks will be copied as symlinks, otherwise the target of the source symlink will be copied.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * The operation can be monitored via the @a slot callback.
   *
   * If the source file does not exist then a Gio::Error with NOT_FOUND will be thrown, independent on the status of the destination.
   *
   * If CopyFlags::OVERWRITE is not specified and the target exists, then a Gio::Error with EXISTS will be thrown.
   *
   * If trying to overwrite a file over a directory a Gio::Error with IS_DIRECTORY will be thrown.
   * If trying to overwrite a directory with a directory a Gio::Error with WOULD_MERGE will be thrown.
   *
   * If the source is a directory and the target does not exist, or CopyFlags::OVERWRITE is specified and the target is a file,
   * then a Gio::Error with WOULD_RECURSE will be thrown.
   *
   * If you are interested in copying the Gio::File object itself (not the on-disk file), see File::dup().
   */
  bool copy(const Glib::RefPtr<File>& destination, const SlotFileProgress& slot, const Glib::RefPtr<Cancellable>& cancellable, CopyFlags flags = CopyFlags::NONE);

  /** Copies the file source to the location specified by destination. Can not handle recursive copies of directories.
   * If the flag CopyFlags::OVERWRITE is specified an already existing destination file is overwritten.
   * If the flag CopyFlags::NOFOLLOW_SYMLINKS is specified then symlinks will be copied as symlinks, otherwise the target of the source symlink will be copied.
   *
   * The operation can be monitored via the @a slot callback.
   *
   * If the source file does not exist then a Gio::Error with NOT_FOUND will be thrown, independent on the status of the destination.
   *
   * If CopyFlags::OVERWRITE is not specified and the target exists, then a Gio::Error with EXISTS will be thrown.
   *
   * If trying to overwrite a file over a directory a Gio::Error with IS_DIRECTORY will be thrown.
   * If trying to overwrite a directory with a directory a Gio::Error with WOULD_MERGE will be thrown.
   *
   * If the source is a directory and the target does not exist, or CopyFlags::OVERWRITE is specified and the target is a file,
   * then a Gio::Error with WOULD_RECURSE will be thrown.
   *
   * If you are interested in copying the Gio::File object itself (not the on-disk file), see File::dup().
   */
  bool copy(const Glib::RefPtr<File>& destination, const SlotFileProgress& slot, CopyFlags flags = CopyFlags::NONE);

  /** Copies the file source to the location specified by destination. Can not handle recursive copies of directories.
   * If the flag CopyFlags::OVERWRITE is specified an already existing destination file is overwritten.
   * If the flag CopyFlags::NOFOLLOW_SYMLINKS is specified then symlinks will be copied as symlinks, otherwise the target of the source symlink will be copied.
   *
   * If the source file does not exist then a Gio::Error with NOT_FOUND will be thrown, independent on the status of the destination.
   *
   * If CopyFlags::OVERWRITE is not specified and the target exists, then a Gio::Error with EXISTS will be thrown.
   *
   * If trying to overwrite a file over a directory a Gio::Error with IS_DIRECTORY will be thrown.
   * If trying to overwrite a directory with a directory a Gio::Error with WOULD_MERGE will be thrown.
   *
   * If the source is a directory and the target does not exist, or CopyFlags::OVERWRITE is specified and the target is a file,
   * then a Gio::Error with WOULD_RECURSE will be thrown.
   *
   * If you are interested in copying the Gio::File object itself (not the on-disk file), see File::dup().
   */
  bool copy(const Glib::RefPtr<File>& destination, CopyFlags flags = CopyFlags::NONE);
  _IGNORE(g_file_copy)

  /** Copies the file to the location specified by @a destination asynchronously.
   * For details of the behaviour, see copy().
   *
   * When the operation is finished, @a slot_ready will be called.
   * You can then call copy_finish() to get the result of the operation.
   *
   * The function specified by @a slot_progress will be called just like
   * in copy(), however the callback will run in the main loop, not in
   * the thread that is doing the I/O operation.
   *
   * @param destination Destination File
   * @param slot_progress The callback slot to be called with progress information
   * @param slot_ready A SlotAsyncReady to call when the request is satisfied
   * @param cancellable A Cancellable object which can be used to cancel the operation
   * @param flags Set of CopyFlags
   * @param io_priority The I/O priority of the request
   */
  void copy_async(const Glib::RefPtr<File>& destination, const SlotFileProgress& slot_progress, const SlotAsyncReady& slot_ready, const Glib::RefPtr<Cancellable>& cancellable, CopyFlags flags = CopyFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);

  /** Copies the file to the location specified by @a destination asynchronously.
   * For details of the behaviour, see copy().
   *
   * When the operation is finished, @a slot_ready will be called.
   * You can then call copy_finish() to get the result of the operation.
   *
   * @param destination Destination File
   * @param slot_ready A SlotAsyncReady to call when the request is satisfied
   * @param cancellable A Cancellable object which can be used to cancel the operation
   * @param flags Set of CopyFlags
   * @param io_priority The I/O priority of the request
   */
  void copy_async(const Glib::RefPtr<File>& destination, const SlotAsyncReady& slot_ready, const Glib::RefPtr<Cancellable>& cancellable, CopyFlags flags = CopyFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);

  /** Copies the file to the location specified by @a destination asynchronously.
   * For details of the behaviour, see copy().
   *
   * When the operation is finished, @a slot_ready will be called.
   * You can then call copy_finish() to get the result of the operation.
   *
   * The function specified by @a slot_progress will be called just like
   * in copy(), however the callback will run in the main loop, not in
   * the thread that is doing the I/O operation.
   *
   * @param destination Destination File
   * @param slot_progress The callback slot to be called with progress information
   * @param slot_ready A SlotAsyncReady to call when the request is satisfied
   * @param flags Set of CopyFlags
   * @param io_priority The I/O priority of the request
   */
  void copy_async(const Glib::RefPtr<File>& destination, const SlotFileProgress& slot_progress, const SlotAsyncReady& slot_ready, CopyFlags flags = CopyFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);

  /** Copies the file to the location specified by @a destination asynchronously.
   * For details of the behaviour, see copy().
   *
   * When the operation is finished, @a slot_ready will be called.
   * You can then call copy_finish() to get the result of the operation.
   *
   * @param destination Destination File
   * @param slot_ready A SlotAsyncReady to call when the request is satisfied
   * @param flags Set of CopyFlags
   * @param io_priority The I/O priority of the request
   */
  void copy_async(const Glib::RefPtr<File>& destination, const SlotAsyncReady& slot_ready, CopyFlags flags = CopyFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);
  _IGNORE(g_file_copy_async)

  _WRAP_METHOD(bool copy_finish(const Glib::RefPtr<AsyncResult>& res),
               g_file_copy_finish,
               errthrow)

  /** 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 and 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 CopyFlags::OVERWRITE is specified an already existing destination file is overwritten.
   *
   * If the flag CopyFlags::NOFOLLOW_SYMLINKS is specified then symlinks will be copied as symlinks, otherwise the target of the source symlink will be copied.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * The operation can be monitored via the @a slot callback.
   * If the source file does not exist then a Gio::Error with NOT_FOUND will be thrown, independent on the status of the destination.
   *
   * If G_CopyFlags::OVERWRITE is not specified and the target exists, then a Gio::Error with EXISTS will be thrown.
   *
   * If trying to overwrite a file over a directory a Gio::Error with IS_DIRECTORY will be thrown.
   * If trying to overwrite a directory with a directory a Gio::Error with WOULD_MERGE will be thrown.
   *
   * If the source is a directory and the target does not exist, or CopyFlags::OVERWRITE is specified and the target is a file, then a Gio::Error with WOULD_RECURSE may be thrown (if the native move operation isn't available).
   */
  bool move(const Glib::RefPtr<File>& destination, const SlotFileProgress& slot, const Glib::RefPtr<Cancellable>& cancellable, CopyFlags flags = CopyFlags::NONE);

  bool move(const Glib::RefPtr<File>& destination, const SlotFileProgress& slot, CopyFlags flags = CopyFlags::NONE);

  bool move(const Glib::RefPtr<File>& destination, CopyFlags flags = CopyFlags::NONE);
  _IGNORE(g_file_move)

  /** Asynchronously moves a file source to the location of @a destination.
   *
   * For details of the behaviour, see move().
   *
   * If @a slot_progress is not empty, then that slot will be called just like
   * in move(). The callback will run in the default main context of the thread
   * calling %move_async() — the same context as @a slot_ready is run in.
   *
   * When the operation is finished, @a slot_ready will be called. You can then call
   * move_finish() to get the result of the operation.
   *
   * @newin{2,72}
   *
   * @param destination File pointing to the destination location.
   * @param slot_progress The callback slot to be called with progress information.
   * @param slot_ready A SlotAsyncReady to call when the request is satisfied.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param flags Set of Gio::File::CopyFlags.
   * @param io_priority The I/O priority of the request.
   */
  void move_async(const Glib::RefPtr<File>& destination, const SlotFileProgress& slot_progress,
    const SlotAsyncReady& slot_ready, const Glib::RefPtr<Cancellable>& cancellable,
    CopyFlags flags = CopyFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);

  void move_async(const Glib::RefPtr<File>& destination,
    const SlotAsyncReady& slot_ready, const Glib::RefPtr<Cancellable>& cancellable,
    CopyFlags flags = CopyFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);

  void move_async(const Glib::RefPtr<File>& destination, const SlotFileProgress& slot_progress,
    const SlotAsyncReady& slot_ready,
    CopyFlags flags = CopyFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);

  void move_async(const Glib::RefPtr<File>& destination,
    const SlotAsyncReady& slot_ready,
    CopyFlags flags = CopyFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);
  _IGNORE(g_file_move_async)

  _WRAP_METHOD(bool move_finish(const Glib::RefPtr<AsyncResult>& res),
               g_file_move_finish, errthrow)

  _WRAP_METHOD(bool make_directory(const Glib::RefPtr<Cancellable>& cancellable{?}),
               g_file_make_directory,
               errthrow)

   /** Asynchronously creates a directory.
    *
    * @param slot_ready A SlotAsyncReady to call when the request is satisfied
    * @param cancellable A Cancellable object which can be used to cancel the operation
    * @param io_priority The I/O priority of the request
    * @newin{2,38}
    */
  void make_directory_async(const SlotAsyncReady& slot_ready, const Glib::RefPtr<Cancellable>& cancellable, int io_priority = Glib::PRIORITY_DEFAULT);

   /** Asynchronously creates a directory.
    *
    * @param slot_ready A SlotAsyncReady to call when the request is satisfied
    * @param io_priority The I/O priority of the request
    * @newin{2,38}
    */
  void make_directory_async(const SlotAsyncReady& slot_ready, int io_priority = Glib::PRIORITY_DEFAULT);
  _IGNORE(g_file_make_directory_async)

  _WRAP_METHOD(bool make_directory_finish(const Glib::RefPtr<AsyncResult>& result),
               g_file_make_directory_finish,
               errthrow)

  _WRAP_METHOD(bool make_directory_with_parents(const Glib::RefPtr<Cancellable>& cancellable{?}),
               g_file_make_directory_with_parents,
               errthrow)

  _WRAP_METHOD(bool make_symbolic_link(const std::string& symlink_value, const Glib::RefPtr<Cancellable>& cancellable{?}),
               g_file_make_symbolic_link,
               errthrow)

  _WRAP_METHOD(void make_symbolic_link_async(const std::string& symlink_value,
    const SlotAsyncReady& slot{callback}, const Glib::RefPtr<Cancellable>& cancellable{.} = {},
    int io_priority{.} = Glib::PRIORITY_DEFAULT), g_file_make_symbolic_link_async,
    slot_name slot, slot_callback SignalProxy_async_callback)

  _WRAP_METHOD(bool make_symbolic_link_finish(const Glib::RefPtr<AsyncResult>& result),
    g_file_make_symbolic_link_finish, errthrow)

  _WRAP_METHOD(Glib::RefPtr<FileAttributeInfoList> query_settable_attributes(const Glib::RefPtr<Cancellable>& cancellable{?}),
               g_file_query_settable_attributes,
               errthrow)

  _WRAP_METHOD(Glib::RefPtr<FileAttributeInfoList> query_writable_namespaces(const Glib::RefPtr<Cancellable>& cancellable{?}),
               g_file_query_writable_namespaces,
               errthrow)

  /* This seems to be very generic (see the gpointer parameter),
     in a C kind of way. Hopefully we don't need it. murrayc
     gboolean                g_file_set_attribute              (GFile                      *file,
							   const char                 *attribute,
							   GFileAttributeType          type,
							   gpointer                    value_p,
							   GFileQueryInfoFlags         flags,
							   GCancellable               *cancellable,
							   GError                    **error);
   */

  /** Tries to set all attributes in the FileInfo on the target values,
   * not stopping on the first error.
   *
   * If there is any error during this operation then a Gio::Error will be thrown.
   * Error on particular fields are flagged by setting
   * the "status" field in the attribute value to
   * FILE_ATTRIBUTE_STATUS_ERROR_SETTING, which means you can also detect
   * further errors.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
   * a Gio::Error with CANCELLED will be thrown.
   *
   * @param info A FileInfo.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param flags A set of FileQueryInfoFlags.
   * @return <tt>true</tt> if there was any error, <tt>false</tt> otherwise.
   */
  bool set_attributes_from_info(const Glib::RefPtr<FileInfo>& info, const Glib::RefPtr<Cancellable>& cancellable, FileQueryInfoFlags flags = FileQueryInfoFlags::NONE);

  /** Tries to set all attributes in the FileInfo on the target values,
   * not stopping on the first error.
   *
   * If there is any error during this operation then a Gio::Error will be thrown.
   * Error on particular fields are flagged by setting
   * the "status" field in the attribute value to
   * FILE_ATTRIBUTE_STATUS_ERROR_SETTING, which means you can also detect
   * further errors.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
   * a Gio::Error with CANCELLED will be thrown.
   *
   * @param info A FileInfo.
   * @param flags A set of FileQueryInfoFlags.
   * @return <tt>true</tt> if there was any error, <tt>false</tt> otherwise.
   */
  bool set_attributes_from_info(const Glib::RefPtr<FileInfo>& info, FileQueryInfoFlags flags = FileQueryInfoFlags::NONE);
  _IGNORE(g_file_set_attributes_from_info)


  /** Asynchronously sets the attributes of file with info.
   *
   * For more details, see set_attributes_from_info() which is the synchronous version of this call.
   * When the operation is finished, @a slot will be called. You can then call set_attributes_finish() to get the result of the operation.
   *
   * @param info A FileInfo.
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param flags A set of FileQueryInfoFlags.
   * @param io_priority The I/O priority of the request.
   */
  void set_attributes_async(const Glib::RefPtr<FileInfo>& info, const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, FileQueryInfoFlags flags = FileQueryInfoFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);

  /** Asynchronously sets the attributes of file with info.
   *
   * For more details, see set_attributes_from_info() which is the synchronous version of this call.
   * When the operation is finished, @a slot will be called. You can then call set_attributes_finish() to get the result of the operation.
   *
   * @param info A FileInfo.
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param flags A set of FileQueryInfoFlags.
   * @param io_priority The I/O priority of the request.
   */
  void set_attributes_async(const Glib::RefPtr<FileInfo>& info, const SlotAsyncReady& slot, FileQueryInfoFlags flags = FileQueryInfoFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);
  _IGNORE(g_file_set_attributes_async)
  _IGNORE(g_file_set_attributes_finish) // takes GFileInfo**

  bool set_attributes_finish(const Glib::RefPtr<AsyncResult>& result, const Glib::RefPtr<FileInfo>& info);

  _WRAP_METHOD(bool set_attribute_string(const std::string& attribute, const Glib::ustring& value, FileQueryInfoFlags flags, const Glib::RefPtr<Cancellable>& cancellable{?}),
               g_file_set_attribute_string,
               errthrow)

  _WRAP_METHOD(bool set_attribute_byte_string(const std::string& attribute, const std::string& value, FileQueryInfoFlags flags, const Glib::RefPtr<Cancellable>& cancellable{?}),
               g_file_set_attribute_byte_string,
               errthrow)

  _WRAP_METHOD(bool set_attribute_uint32(const std::string& attribute, guint32 value, FileQueryInfoFlags flags, const Glib::RefPtr<Cancellable>& cancellable{?}),
               g_file_set_attribute_uint32,
               errthrow)

  _WRAP_METHOD(bool set_attribute_int32(const std::string& attribute, gint32 value, FileQueryInfoFlags flags, const Glib::RefPtr<Cancellable>& cancellable{?}),
               g_file_set_attribute_int32,
               errthrow)

  _WRAP_METHOD(bool set_attribute_uint64(const std::string& attribute, guint64 value, FileQueryInfoFlags flags, const Glib::RefPtr<Cancellable>& cancellable{?}),
               g_file_set_attribute_uint64,
               errthrow)

  _WRAP_METHOD(bool set_attribute_int64(const std::string& attribute, gint64 value, FileQueryInfoFlags flags, const Glib::RefPtr<Cancellable>& cancellable{?}),
               g_file_set_attribute_int64,
               errthrow)

  /** Starts a @a mount_operation, mounting the volume that contains the file.
   *
   * When this operation has completed, @a slot will be called with,
   * and the operation can be finalized with mount_enclosing_volume_finish().
   *
   * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
   * a Gio::Error with CANCELLED will be thrown.
   *
   * @param mount_operation A MountOperation.
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object.
   * @param flags Flags affecting the operation.
   */
  void mount_enclosing_volume(const Glib::RefPtr<MountOperation>& mount_operation, const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, Mount::MountFlags flags = Mount::MountFlags::NONE);

  /** Starts a @a mount_operation, mounting the volume that contains the file.
   *
   * When this operation has completed, @a slot will be called with,
   * and the operation can be finalized with mount_enclosing_volume_finish().
   *
   * @param mount_operation A MountOperation.
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param flags Flags affecting the operation.
   */
  void mount_enclosing_volume(const Glib::RefPtr<MountOperation>& mount_operation, const SlotAsyncReady& slot, Mount::MountFlags flags = Mount::MountFlags::NONE);

  /** Starts a @a mount_operation, mounting the volume that contains the file.
   *
   * When this operation has completed, @a slot will be called with,
   * and the operation can be finalized with mount_enclosing_volume_finish().
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param flags Flags affecting the operation.
   */
  void mount_enclosing_volume(const SlotAsyncReady& slot, Mount::MountFlags flags = Mount::MountFlags::NONE);
  _IGNORE(g_file_mount_enclosing_volume)

  /** Starts a @a mount_operation, mounting the volume that contains the file.
   *
   * @param flags Flags affecting the operation.
   */
  void mount_enclosing_volume(Mount::MountFlags flags = Mount::MountFlags::NONE);
  _IGNORE(g_file_mount_enclosing_volume)

  _WRAP_METHOD(bool mount_enclosing_volume_finish(const Glib::RefPtr<AsyncResult>& result),
               g_file_mount_enclosing_volume_finish,
               errthrow)

  /** Mounts a file of type FILE_TYPE_MOUNTABLE. Using @a mount_operation, you can request callbacks when, for instance,
   * passwords are needed during authentication.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
   * a Gio::Error with CANCELLED will be thrown.
   *
   * When the operation is finished, @a slot will be called. You can then call mount_mountable_finish() to get the result of the operation.
   *
   * @param mount_operation A MountOperation.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param flags Flags affecting the operation.
   */
  void mount_mountable(const Glib::RefPtr<MountOperation>& mount_operation, const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, Mount::MountFlags flags = Mount::MountFlags::NONE);

  /** Mounts a file of type FILE_TYPE_MOUNTABLE. Using @a mount_operation, you can request callbacks when, for instance,
   * passwords are needed during authentication.
   *
   * When the operation is finished, @a slot will be called. You can then call mount_mountable_finish() to get the result of the operation.
   *
   * @param mount_operation A MountOperation.
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param flags Flags affecting the operation.
   */
  void mount_mountable(const Glib::RefPtr<MountOperation>& mount_operation, const SlotAsyncReady& slot, Mount::MountFlags flags = Mount::MountFlags::NONE);

  /** Mounts a file of type FILE_TYPE_MOUNTABLE without user interaction.
   *
   * When the operation is finished, @a slot will be called. You can then call mount_mountable_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param flags Flags affecting the operation.
   */
  void mount_mountable(const SlotAsyncReady& slot, Mount::MountFlags flags = Mount::MountFlags::NONE);

  /** Mounts a file of type FILE_TYPE_MOUNTABLE without user interaction.
   *
   * @param flags Flags affecting the operation.
   */
  void mount_mountable(Mount::MountFlags flags = Mount::MountFlags::NONE);
  _IGNORE(g_file_mount_mountable)

  _WRAP_METHOD(Glib::RefPtr<File> mount_mountable_finish(const Glib::RefPtr<AsyncResult>& result),
               g_file_mount_mountable_finish,
               errthrow)

  /** Unmounts a file of type FILE_TYPE_MOUNTABLE.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
   * a Gio::Error with CANCELLED will be thrown.
   *
   * When the operation is finished, @a slot will be called. You can then call unmount_mountable_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param flags Flags affecting the operation.
   */
  void unmount_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, Mount::UnmountFlags flags = Mount::UnmountFlags::NONE);

  /** Unmounts a file of type FILE_TYPE_MOUNTABLE.
   *
   * When the operation is finished, @a slot will be called. You can then call unmount_mountable_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param flags Flags affecting the operation.
   */
  void unmount_mountable(const SlotAsyncReady& slot, Mount::UnmountFlags flags = Mount::UnmountFlags::NONE);

  /** Unmounts a file of type FILE_TYPE_MOUNTABLE.
   *
   * @param flags Flags affecting the operation.
   */
  void unmount_mountable(Mount::UnmountFlags flags = Mount::UnmountFlags::NONE);

  /** Unmounts a file of type FILE_TYPE_MOUNTABLE.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
   * a Gio::Error with CANCELLED will be thrown.
   *
   * When the operation is finished, @a slot will be called. You can then call unmount_mountable_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param mount_operation A MountOperation
   * @param flags Flags affecting the operation.
   *
   * @newin{2,24}
   */
  void unmount_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const Glib::RefPtr<MountOperation>& mount_operation, Mount::UnmountFlags flags = Mount::UnmountFlags::NONE);

  /** Unmounts a file of type FILE_TYPE_MOUNTABLE.
   *
   * When the operation is finished, @a slot will be called. You can then call unmount_mountable_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param mount_operation A MountOperation
   * @param flags Flags affecting the operation.
   *
   * @newin{2,24}
   */
  void unmount_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<MountOperation>& mount_operation, Mount::UnmountFlags flags = Mount::UnmountFlags::NONE);

  /** Unmounts a file of type FILE_TYPE_MOUNTABLE.
   *
   * @param mount_operation A MountOperation
   * @param flags Flags affecting the operation.
   *
   * @newin{2,24}
   */
  void unmount_mountable(const Glib::RefPtr<MountOperation>& mount_operation, Mount::UnmountFlags flags = Mount::UnmountFlags::NONE);

  _IGNORE(g_file_unmount_mountable, g_file_unmount_mountable_finish, g_file_unmount_mountable_with_operation)

  _WRAP_METHOD(bool unmount_mountable_finish(const Glib::RefPtr<AsyncResult>& result),
               g_file_unmount_mountable_with_operation_finish,
               errthrow)

  /** Starts an asynchronous eject on a mountable.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
   * a Gio::Error with CANCELLED will be thrown.
   *
   * When the operation is finished, @a slot will be called. You can then call eject_mountable_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param flags Flags affecting the operation.
   */
  void eject_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, Mount::UnmountFlags flags = Mount::UnmountFlags::NONE);

  /** Starts an asynchronous eject on a mountable.
   *
   * When the operation is finished, @a slot will be called. You can then call eject_mountable_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param flags Flags affecting the operation.
   */
  void eject_mountable(const SlotAsyncReady& slot, Mount::UnmountFlags flags = Mount::UnmountFlags::NONE);

  /** Starts an asynchronous eject on a mountable.
   *
   * @param flags Flags affecting the operation.
   */
  void eject_mountable(Mount::UnmountFlags flags = Mount::UnmountFlags::NONE);

  /** Starts an asynchronous eject on a mountable.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
   * a Gio::Error with CANCELLED will be thrown.
   *
   * When the operation is finished, @a slot will be called. You can then call eject_mountable_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   * @param mount_operation A MountOperation
   * @param flags Flags affecting the operation.
   *
   * @newin{2,24}
   */
  void eject_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const Glib::RefPtr<MountOperation>& mount_operation, Mount::UnmountFlags flags = Mount::UnmountFlags::NONE);

  /** Starts an asynchronous eject on a mountable.
   *
   * When the operation is finished, @a slot will be called. You can then call eject_mountable_finish() to get the result of the operation.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param mount_operation A MountOperation
   * @param flags Flags affecting the operation.
   *
   * @newin{2,24}
   */
  void eject_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<MountOperation>& mount_operation, Mount::UnmountFlags flags = Mount::UnmountFlags::NONE);

  /** Starts an asynchronous eject on a mountable.
   *
   * @param mount_operation A MountOperation
   * @param flags Flags affecting the operation.
   *
   * @newin{2,24}
   */
  void eject_mountable(const Glib::RefPtr<MountOperation>& mount_operation, Mount::UnmountFlags flags = Mount::UnmountFlags::NONE);

  _IGNORE(g_file_eject_mountable, g_file_eject_mountable_finish, g_file_eject_mountable_with_operation)

  _WRAP_METHOD(bool eject_mountable_finish(const Glib::RefPtr<AsyncResult>& result),
               g_file_eject_mountable_with_operation_finish,
               errthrow)


  /** Copies the file attributes from @a source to @a destination.
   *
   * Normally only a subset of the file attributes are copied,
   * those that are copies in a normal file copy operation
   * (which for instance does not include e.g. mtime). However
   * if CopyFlags::ALL_METADATA is specified in @a flags, then
   * all the metadata that is possible to copy is copied.
   *
   * @param destination A File to copy attributes to.
   * @param cancellable A Cancellable object.
   * @param flags A set of FileMonitorFlags.
   * @result true if the attributes were copied successfully, false otherwise.
   */
  bool copy_attributes(const Glib::RefPtr<File>& destination, const Glib::RefPtr<Cancellable>& cancellable, CopyFlags flags = CopyFlags::NONE);

  /** Copies the file attributes from @a source to @a destination.
   *
   * Normally only a subset of the file attributes are copied,
   * those that are copies in a normal file copy operation
   * (which for instance does not include e.g. mtime). However
   * if CopyFlags::ALL_METADATA is specified in @a flags, then
   * all the metadata that is possible to copy is copied.
   *
   * @param destination A File to copy attributes to.
   * @param flags A set of FileMonitorFlags.
   * @result true if the attributes were copied successfully, false otherwise.
   */
  bool copy_attributes(const Glib::RefPtr<File>& destination, CopyFlags flags = CopyFlags::NONE);
  _IGNORE(g_file_copy_attributes)

  /** Obtains a directory monitor for the given file.
   * This may fail if directory monitoring is not supported.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread. If the operation
   * was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * @param cancellable A Cancellable object.
   * @param flags A set of FileMonitorFlags.
   * @return A FileMonitor for the file.
   */
  Glib::RefPtr<FileMonitor> monitor_directory(const Glib::RefPtr<Cancellable>& cancellable, FileMonitorFlags flags = FileMonitorFlags::NONE);

  /** Obtains a directory monitor for the given file.
   * This may fail if directory monitoring is not supported.
   *
   * @param flags A set of FileMonitorFlags.
   * @return A FileMonitor for the file.
   */
  Glib::RefPtr<FileMonitor> monitor_directory(FileMonitorFlags flags = FileMonitorFlags::NONE);
  _IGNORE(g_file_monitor_directory)

  /** Obtains a file monitor for the given file. If no file notification
   * mechanism exists, then regular polling of the file is used.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread. If the operation
   * was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * @param cancellable A Cancellable object.
   * @param flags A set of FileMonitorFlags.
   * @return A FileMonitor for the file.
   */
  Glib::RefPtr<FileMonitor> monitor_file(const Glib::RefPtr<Cancellable>& cancellable, FileMonitorFlags flags = FileMonitorFlags::NONE);

  /** Obtains a file monitor for the given file. If no file notification
   * mechanism exists, then regular polling of the file is used.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread. If the operation
   * was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * @param flags A set of FileMonitorFlags.
   * @return A FileMonitor for the file.
   */
  Glib::RefPtr<FileMonitor> monitor_file(FileMonitorFlags flags = FileMonitorFlags::NONE);
  _IGNORE(g_file_monitor_file)


  /** Obtains a file monitor for the given file. If no file notification
   * mechanism exists, then regular polling of the file is used.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread. If the operation
   * was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * @param cancellable A Cancellable object.
   * @param flags A set of FileMonitorFlags.
   * @return A FileMonitor for the file.
   *
   * @newin{2,18}
   */
  Glib::RefPtr<FileMonitor> monitor(const Glib::RefPtr<Cancellable>& cancellable, FileMonitorFlags flags = FileMonitorFlags::NONE);

  /** Obtains a file monitor for the given file. If no file notification
   * mechanism exists, then regular polling of the file is used.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread. If the operation
   * was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * @param flags A set of FileMonitorFlags.
   * @return A FileMonitor for the file.
   *
   * @newin{2,18}
   */
  Glib::RefPtr<FileMonitor> monitor(FileMonitorFlags flags = FileMonitorFlags::NONE);
  _IGNORE(g_file_monitor)


 /** This slot type is used by measure_disk_usage() to make
  * periodic progress reports when measuring the amount of disk spaced
  * used by a directory.
  *
  * These calls are made on a best-effort basis and not all types of
  * GFile will support them.  At the minimum, however, one call will
  * always be made immediately.
  *
  * In the case that there is no support, @a reporting will be set to
  * false (and the other values undefined) and no further calls will be
  * made.  Otherwise, the @a reporting will be true and the other values
  * all-zeros during the first (immediate) call.  In this way, you can
  * know which type of progress UI to show without a delay.
  *
  * For measure_disk_usage() the callback is made directly.  For
  * measure_disk_usage_async() the callback is made via the
  * default main context of the calling thread (ie: the same way that the
  * final async result would be reported).
  *
  * @a current_size is in the same units as requested by the operation (see
  * FILE_DISK_USAGE_APPARENT_SIZE).
  *
  * The frequency of the updates is implementation defined, but is
  * ideally about once every 200ms.
  *
  * The last progress callback may or may not be equal to the final
  * result.  Always check the async result to get the final value.
  *
  * For instance,
  * void on_file_measure_progress(bool reporting, guint64 current_size, guint64 num_dirs, guint64 num_files);
  *
  * @param reporting true if more reports will come.
  * @param current_size The current cumulative size measurement.
  * @param num_dirs The number of directories visited so far.
  * @param num_files The number of non-directory files encountered.
  *
  * @newin{2,38}
  */
 using SlotFileMeasureProgress = sigc::slot<void(bool, guint64, guint64, guint64)>;

  //We do not use the {callback} syntax with _WRAP_METHOD here, because it expects to use user_data rather than progress_data.
  //We ignore the gboolean result, because we throw an exception if it is false.
  /** Recursively measures the disk usage of the file.
   *
   * This is essentially an analog of the '<tt>du</tt>' 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
   * FILE_DISK_USAGE_REPORT_ALL_ERRORS is given in @a flags.
   *
   * The returned size, @a 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.
   *
   * @a slot_progress can be given to request periodic progress updates while scanning.
   * See the documentation for SlotFileMeasureProgress for information about when and how the
   * callback will be invoked.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread.
   * If the operation was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * @param cancellable A Cancellable object which can be used to cancel the operation
   * @param slot_progress A SlotFileMeasureProgress to call periodically while scanning.
   * @param disk_usage The number of bytes of disk space used.
   * @param num_dirs The number of directories encountered.
   * @param num_files The number of non-directories encountered.
   * @param flags Set of MeasureFlags.
   */
  void measure_disk_usage(const Glib::RefPtr<Cancellable>& cancellable, const SlotFileMeasureProgress& slot_progress, guint64& disk_usage, guint64& num_dirs, guint64& num_files, MeasureFlags flags = MeasureFlags::NONE);
  _IGNORE(g_file_measure_disk_usage)

  /** Recursively measures the disk usage of the file.
   *
   * This is the asynchronous version of measure_disk_usage().  See
   * there for more information.
   *
   * When the operation is finished, @a slot_ready will be called.
   * You can then call measure_disk_usage_finish() to get the result of the operation.
   *
   * @param slot_ready A SlotAsyncReady to call when the request is satisfied
   * @param cancellable A Cancellable object which can be used to cancel the operation
   * @param slot_progress The callback slot to be called with progress information
   * @param flags Set of MeasureFlags
   * @param io_priority The I/O priority of the request
   */
  void measure_disk_usage_async(const SlotAsyncReady& slot_ready, const Glib::RefPtr<Cancellable>& cancellable, const SlotFileMeasureProgress& slot_progress, MeasureFlags flags = MeasureFlags::NONE, int io_priority = Glib::PRIORITY_DEFAULT);
  _IGNORE(g_file_measure_disk_usage_async)

  _WRAP_METHOD(bool measure_disk_usage_finish(const Glib::RefPtr<AsyncResult>& result, guint64& disk_usage, guint64& num_dirs, guint64& num_files), g_file_measure_disk_usage_finish, errthrow)



 //TODO: The documentation for these start/stop/poll_mountable functions needs to be improved once we've figured out what they do and what the C documentation means. murrayc.

 /** Starts a file of type Mountable.
  * Using @a start_operation, you can request callbacks when, for instance,
  * passwords are needed during authentication.
  *
  * When this operation has completed, @a slot will be called
  * and the operation can be finalized with start_mountable_finish().
  *
  * The operation can be cancelled by
  * triggering the cancellable object from another thread. If the operation
  * was cancelled, a Gio::Error with CANCELLED will be thrown.
  *
  * @param slot A callback to call when the request is satisfied.
  * @param cancellable A Cancellable object.
  * @param start_operation A MountOperation, or <tt>nullptr</tt> to avoid user interaction.
  * @param flags Flags affecting the operation
  *
  * @newin{2,24}
  */
  void start_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const Glib::RefPtr<MountOperation>& start_operation, Drive::StartFlags flags = Drive::StartFlags::NONE);

 /** Starts a file of type Mountable.
  * Using @a start_operation, you can request callbacks when, for instance,
  * passwords are needed during authentication.
  *
  * When this operation has completed, @a slot will be called
  * and the operation can be finalized with start_mountable_finish().
  *
  * The operation can be cancelled by
  * triggering the cancellable object from another thread. If the operation
  * was cancelled, a Gio::Error with CANCELLED will be thrown.
  *
  * @param slot A callback to call when the request is satisfied.
  * @param start_operation A MountOperation, or <tt>nullptr</tt> to avoid user interaction.
  * @param flags Flags affecting the operation
  *
  * @newin{2,24}
  */
  void start_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<MountOperation>& start_operation, Drive::StartFlags flags =  Drive::StartFlags::NONE);
  _IGNORE(g_file_start_mountable)

  _WRAP_METHOD(bool start_mountable_finish(const Glib::RefPtr<AsyncResult>& result),
               g_file_start_mountable_finish, errthrow)


 /** Stops a file of type Mountable.
  * Using @a start_operation, you can request callbacks when, for instance,
  * passwords are needed during authentication.
  *
  * When this operation has completed, @a slot will be called
  * and the operation can be finalized with stop_mountable_finish().
  *
  * The operation can be cancelled by
  * triggering the cancellable object from another thread. If the operation
  * was cancelled, a Gio::Error with CANCELLED will be thrown.
  *
  * @param slot A callback to call when the request is satisfied.
  * @param cancellable A Cancellable object.
  * @param start_operation A MountOperation, or <tt>nullptr</tt> to avoid user interaction.
  * @param flags Flags affecting the operation
  *
  * @newin{2,24}
  */
  void stop_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const Glib::RefPtr<MountOperation>& start_operation, Mount::UnmountFlags flags = Mount::UnmountFlags::NONE);


 /** Stops a file of type Mountable.
  * Using @a start_operation, you can request callbacks when, for instance,
  * passwords are needed during authentication.
  *
  * When this operation has completed, @a slot will be called
  * and the operation can be finalized with stop_mountable_finish().
  *
  * The operation can be cancelled by
  * triggering the cancellable object from another thread. If the operation
  * was cancelled, a Gio::Error with CANCELLED will be thrown.
  *
  * @param slot A callback to call when the request is satisfied.
  * @param start_operation A MountOperation, or <tt>nullptr</tt> to avoid user interaction.
  * @param flags Flags affecting the operation
  *
  * @newin{2,24}
  */
  void stop_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<MountOperation>& start_operation, Mount::UnmountFlags flags = Mount::UnmountFlags::NONE);
  _IGNORE(g_file_stop_mountable)

  _WRAP_METHOD(bool stop_mountable_finish(const Glib::RefPtr<AsyncResult>& result),
               g_file_stop_mountable_finish, errthrow)


 /** Polls a file of type Mountable.
  * Using @a start_operation, you can request callbacks when, for instance,
  * passwords are needed during authentication.
  *
  * When this operation has completed, @a slot will be called
  * and the operation can be finalized with stop_mountable_finish().
  *
  * The operation can be cancelled by
  * triggering the cancellable object from another thread. If the operation
  * was cancelled, a Gio::Error with CANCELLED will be thrown.
  *
  * @param slot: A callback to call when the request is satisfied.
  * @param cancellable A Cancellable object.
  *
  * @newin{2,24}
  */
  void poll_mountable(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable);


 /** Polls a file of type Mountable.
  * Using @a start_operation, you can request callbacks when, for instance,
  * passwords are needed during authentication.
  *
  * When this operation has completed, @a slot will be called
  * and the operation can be finalized with stop_mountable_finish().
  *
  * The operation can be cancelled by
  * triggering the cancellable object from another thread. If the operation
  * was cancelled, a Gio::Error with CANCELLED will be thrown.
  *
  * @param slot: A callback to call when the request is satisfied.
  *
  * @newin{2,24}
  */
  void poll_mountable(const SlotAsyncReady& slot);
  _IGNORE(g_file_poll_mountable)

  _WRAP_METHOD(bool poll_mountable_finish(const Glib::RefPtr<AsyncResult>& result),
               g_file_poll_mountable_finish, errthrow)

  _WRAP_METHOD(Glib::RefPtr<AppInfo> query_default_handler(const Glib::RefPtr<Cancellable>& cancellable{?}),
               g_file_query_default_handler,
               errthrow)

  //TODO: Something better than char*& for contents?
  /** Loads the content of the file into memory, returning the size of the data.
   * The data is always zero terminated, but this is not included in the resultant @a length.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread.
   * If the operation was cancelled, a Gio::Error exception with CANCELLED will be returned.
   *
   * @param cancellable A cancellable object.
   * @param contents A location to place the contents of the file.
   * @param length A location to place the length of the contents of the file.
   * @param etag_out A location to place the current entity tag for the file.
   */
  bool load_contents(const Glib::RefPtr<Cancellable>& cancellable, char*& contents, gsize& length, std::string& etag_out);

  /** Loads the content of the file into memory, returning the size of the data.
   * The data is always zero terminated, but this is not included in the resultant @a length.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread.
   * If the operation was cancelled, a Gio::Error exception with CANCELLED will be returned.
   *
   * @param cancellable A cancellable object.
   * @param contents A location to place the contents of the file.
   * @param length A location to place the length of the contents of the file.
   * @newin{2,22}
   */
  bool load_contents(const Glib::RefPtr<Cancellable>& cancellable, char*& contents, gsize& length);

  //TODO: Something better than char*& for contents?
  /** Loads the content of the file into memory, returning the size of the data.
   * The data is always zero terminated, but this is not included in the resultant @a length.
   *
   * @param contents A location to place the contents of the file.
   * @param length A location to place the length of the contents of the file.
   * @param etag_out A location to place the current entity tag for the file.
   */
  bool load_contents(char*& contents, gsize& length, std::string& etag_out);

  /** Loads the content of the file into memory, returning the size of the data.
   * The data is always zero terminated, but this is not included in the resultant @a length.
   *
   * @param contents A location to place the contents of the file.
   * @param length A location to place the length of the contents of the file.
   * @newin{2,22}
   */
  bool load_contents(char*& contents, gsize& length);
  _IGNORE(g_file_load_contents)

  /** Starts an asynchronous load of the file's contents.
   * For more details, see load_contents() which is the synchronous version of this call.
   *
   * When the load operation has completed, the @a slot will be called. To finish the operation,
   * call load_contents_finish() with the AsyncResult provided to the @a slot.
   *
   * The operation can be cancelled by triggering the cancellable object from another thread.
   * If the operation was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object.
   */
  void load_contents_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable);

  /** Starts an asynchronous load of the file's contents.
   * For more details, see load_contents() which is the synchronous version of this call.
   *
   * When the load operation has completed, the @a slot will be called. To finish the operation,
   * call load_contents_finish() with the AsyncResult provided to the @a slot.
   *
   * @param slot A callback slot which will be called when the request is satisfied.
   */
  void load_contents_async(const SlotAsyncReady& slot);
  _IGNORE(g_file_load_contents_async)

  /** Finishes an asynchronous load of the @a file's contents.
   * The contents are placed in @a contents, and @a length is set to the
   * size of the @a contents string. If @a etag_out is present, it will be
   * set to the new entity tag for the @a file.
   * @param result A AsyncResult.
   * @param contents A location to place the contents of the file.
   * @param length A location to place the length of the contents of the file.
   * @param etag_out A location to place the current entity tag for the file.
   * @return <tt>true</tt> if the load was successful. If <tt>false</tt> and @a error is
   * present, it will be set appropriately.
   */
  bool load_contents_finish(const Glib::RefPtr<AsyncResult>& result, char*& contents, gsize& length, std::string& etag_out);

  /** Finishes an asynchronous load of the @a file's contents.
   * The contents are placed in @a contents, and @a length is set to the
   * size of the @a contents string. If @a etag_out is present, it will be
   * set to the new entity tag for the @a file.
   * @param result A AsyncResult.
   * @param contents A location to place the contents of the file.
   * @param length A location to place the length of the contents of the file.
   * @return <tt>true</tt> if the load was successful. If <tt>false</tt> and @a error is
   * present, it will be set appropriately.
   * @newin{2,22}
   */
  bool load_contents_finish(const Glib::RefPtr<AsyncResult>& result, char*& contents, gsize& length);
  _IGNORE(g_file_load_contents_finish)


  /** A signal handler would be, for instance:
   * bool on_read_more(const char* file_contents, goffset file_size);
   */
  using SlotReadMore = sigc::slot<bool(const char*, goffset)>;

  //Note that slot_read_more can be nullptr but that would not be a useful method overload, because the documentation says that it would
  //then be equivalent to load_contents_async.

  /** Reads the partial contents of a file.
   * The @a slot_read_more callback slot should be used to stop reading from the file when appropriate. This operation can be finished by load_partial_contents_finish().
   *
   * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
   * a Gio::Error with CANCELLED will be thrown.
   *
   * When the operation is finished, @a slot will be called. You can then call load_partial_contents_finish() to get the result of the operation.
   *
   * @param slot_read_more A callback to receive partial data and to specify whether further data should be read.
   * @param slot_async_ready A callback slot which will be called when the request is satisfied.
   * @param cancellable A Cancellable object which can be used to cancel the operation.
   */
  void load_partial_contents_async(const SlotReadMore& slot_read_more, const SlotAsyncReady& slot_async_ready, const Glib::RefPtr<Cancellable>& cancellable);

  /** Reads the partial contents of a file.
   * The @a slot_read_more callback slot should be used to stop reading from the file when appropriate. This operation can be finished by load_partial_contents_finish().
   *
   * The operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled,
   * a Gio::Error with CANCELLED will be thrown.
   *
   * When the operation is finished, @a slot will be called. You can then call load_partial_contents_finish() to get the result of the operation.
   *
   * @param slot_read_more A callback to receive partial data and to specify whether further data should be read.
   * @param slot_async_ready A callback slot which will be called when the request is satisfied.
   */
  void load_partial_contents_async(const SlotReadMore& slot_read_more, const SlotAsyncReady& slot_async_ready);
  _IGNORE(g_file_load_partial_contents_async)


  /** Finishes an asynchronous partial load operation that was started
   * with load_partial_contents_async().
   * @param result A AsyncResult.
   * @param contents A location to place the contents of the file.
   * @param length A location to place the length of the contents of the file.
   * @param etag_out A location to place the current entity tag for the file.
   * @return <tt>true</tt> if the load was successful. If <tt>false</tt> and @a error is
   * present, it will be set appropriately.
   */
  bool load_partial_contents_finish(const Glib::RefPtr<AsyncResult>& result, char*& contents, gsize& length, std::string& etag_out);

  /** Finishes an asynchronous partial load operation that was started
   * with load_partial_contents_async().
   * @param result A AsyncResult.
   * @param contents A location to place the contents of the file.
   * @param length A location to place the length of the contents of the file.
   * @return <tt>true</tt> if the load was successful. If <tt>false</tt> and @a error is
   * present, it will be set appropriately.
   * @newin{2,22}
   */
  bool load_partial_contents_finish(const Glib::RefPtr<AsyncResult>& result, char*& contents, gsize& length);
  _IGNORE(g_file_load_partial_contents_finish)

  /** Replaces the contents of the file with @a contents of @a length bytes.
   *
   * If @a etag is specified (not an empty string) any existing file must have that etag, or
   * a Gio::Error with WRONG_ETAG will be thrown.
   *
   * If @a make_backup is <tt>true</tt>, this function will attempt to make a backup of the file.
   *
   * The operation can be cancelled by
   * triggering the cancellable object from another thread. If the operation
   * was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * The returned @a new_etag  can be used to verify that the file hasn't changed the
   * next time it is saved over.
   * @param contents A string containing the new contents for the file.
   * @param length The length of @a contents in bytes.
   * @param etag The old entity tag
   * for the document.
   * @param make_backup <tt>true</tt> if a backup should be created.
   * @param flags A set of CreateFlags.
   * @param new_etag A location to a new entity tag
   * for the document.
   * @param cancellable A Cancellable object.
   */
  void replace_contents(const char* contents, gsize length, const std::string& etag, std::string& new_etag, const Glib::RefPtr<Cancellable>& cancellable, bool make_backup = false, CreateFlags flags = CreateFlags::NONE);

  /** Replaces the contents of the file with @a contents of @a length bytes.
   *
   * If @a etag is specified (not an empty string) any existing file must have that etag, or
   * a Gio::Error with WRONG_ETAG will be thrown.
   *
   * If @a make_backup is <tt>true</tt>, this function will attempt to make a backup of the file.
   *
   * The returned @a new_etag  can be used to verify that the file hasn't changed the
   * next time it is saved over.
   * @param contents A string containing the new contents for the file.
   * @param length The length of @a contents in bytes.
   * @param etag The old entity tag
   * for the document.
   * @param make_backup <tt>true</tt> if a backup should be created.
   * @param flags A set of CreateFlags.
   * @param new_etag A location to a new entity tag
   * for the document.
   */
  void replace_contents(const char* contents, gsize length, const std::string& etag, std::string& new_etag, bool make_backup = false, CreateFlags flags = CreateFlags::NONE);

  /** Replaces the contents of the file with @a contents.
   *
   * If @a etag is specified (not an empty string) any existing file must have that etag, or
   * a Gio::Error with WRONG_ETAG will be thrown.
   *
   * If @a make_backup is <tt>true</tt>, this function will attempt to make a backup of the file.
   *
   * The operation can be cancelled by
   * triggering the cancellable object from another thread. If the operation
   * was cancelled, a Gio::Error with CANCELLED will be thrown.
   *
   * The returned @a new_etag  can be used to verify that the file hasn't changed the
   * next time it is saved over.
   * @param contents A string containing the new contents for the file.
   * @param etag The old entity tag
   * for the document.
   * @param make_backup <tt>true</tt> if a backup should be created.
   * @param flags A set of CreateFlags.
   * @param new_etag A location to a new entity tag
   * for the document.
   * @param cancellable A Cancellable object.
   */
  void replace_contents(const std::string& contents, const std::string& etag, std::string& new_etag, const Glib::RefPtr<Cancellable>& cancellable, bool make_backup = false, CreateFlags flags = CreateFlags::NONE);

  /** Replaces the contents of the file with @a contents.
   *
   * If @a etag is specified (not an empty string) any existing file must have that etag, or
   * a Gio::Error with WRONG_ETAG will be thrown.
   *
   * If @a make_backup is <tt>true</tt>, this function will attempt to make a backup of the file.
   *
   * The returned @a new_etag  can be used to verify that the file hasn't changed the
   * next time it is saved over.
   * @param contents A string containing the new contents for the file.
   * @param etag The old entity tag
   * for the document.
   * @param make_backup <tt>true</tt> if a backup should be created.
   * @param flags A set of CreateFlags.
   * @param new_etag A location to a new entity tag
   * for the document.
   */
  void replace_contents(const std::string& contents, const std::string& etag, std::string& new_etag, bool make_backup = false, CreateFlags flags = CreateFlags::NONE);
  _IGNORE(g_file_replace_contents)


  //TODO: Add replace_contents() without the etags?


 /** Starts an asynchronous replacement of the file with the given
  * @a contents of @a length bytes. @a etag will replace the document's
  * current entity tag.
  *
  * When this operation has completed, @a slot will be called
  * and the operation can be finalized with replace_contents_finish().
  *
  * The operation can be cancelled by
  * triggering the cancellable object from another thread. If the operation
  * was cancelled, a Gio::Error with CANCELLED will be thrown.
  *
  * If @a make_backup is true, this function will attempt to
  * make a backup of the file.
  *
  * @param slot: A callback to call when the request is satisfied.
  * @param cancellable A Cancellable object.
  * @param contents String of contents to replace the file with.
  * @param length The length of @a contents in bytes.
  * @param etag a new entity tag for the file.
  * @param make_backup true if a backup should be created.
  * @param flags A set of CreateFlags.
  */
  void replace_contents_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const char* contents, gsize length, const std::string& etag, bool make_backup = false, CreateFlags flags = CreateFlags::NONE);

 /** Starts an asynchronous replacement of the file with the given
  * @a contents of @a length bytes. @a etag will replace the document's
  * current entity tag.
  *
  * When this operation has completed, @a slot will be called
  * and the operation can be finalized with replace_contents_finish().
  *
  * If @a make_backup is true, this function will attempt to
  * make a backup of the file.
  *
  * @param slot: A callback to call when the request is satisfied.
  * @param contents String of contents to replace the file with.
  * @param length The length of @a contents in bytes.
  * @param etag a new entity tag for the file.
  * @param make_backup true if a backup should be created.
  * @param flags A set of CreateFlags.
  */
  void replace_contents_async(const SlotAsyncReady& slot, const char* contents, gsize length, const std::string& etag, bool make_backup = false, CreateFlags flags = CreateFlags::NONE);

 /** Starts an asynchronous replacement of the file with the given
  * @a contents of @a length bytes. @a etag will replace the document's
  * current entity tag.
  *
  * When this operation has completed, @a slot will be called
  * and the operation can be finalized with replace_contents_finish().
  *
  * The operation can be cancelled by
  * triggering the cancellable object from another thread. If the operation
  * was cancelled, a Gio::Error with CANCELLED will be thrown.
  *
  * If @a make_backup is true, this function will attempt to
  * make a backup of the file.
  *
  * @param slot: A callback to call when the request is satisfied.
  * @param cancellable A Cancellable object.
  * @param contents String of contents to replace the file with.
  * @param etag a new entity tag for the file.
  * @param make_backup true if a backup should be created.
  * @param flags A set of CreateFlags.
  */
  void replace_contents_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const std::string& contents, const std::string& etag, bool make_backup = false, CreateFlags flags = CreateFlags::NONE);

 /** Starts an asynchronous replacement of the file with the given
  * @a contents. @a etag will replace the document's
  * current entity tag.
  *
  * When this operation has completed, @a slot will be called
  * and the operation can be finalized with replace_contents_finish().
  *
  * The operation can be cancelled by
  * triggering the cancellable object from another thread. If the operation
  * was cancelled, a Gio::Error with CANCELLED will be thrown.
  *
  * If @a make_backup is true, this function will attempt to
  * make a backup of the file.
  *
  * @param slot: A callback to call when the request is satisfied.
  * @param contents String of contents to replace the file with.
  * @param etag a new entity tag for the file.
  * @param make_backup true if a backup should be created.
  * @param flags A set of CreateFlags.
  */
  void replace_contents_async(const SlotAsyncReady& slot, const std::string& contents, const std::string& etag, bool make_backup = false, CreateFlags flags = CreateFlags::NONE);

  _IGNORE(g_file_replace_contents_async)

  /** Finishes an asynchronous replace of the given file . See
   * replace_contents_async(). Sets @a new_etag to the new entity
   * tag for the document.
   * @param result A AsyncResult.
   * @param new_etag A location of a new entity tag
   * for the document.
   */
  void replace_contents_finish(const Glib::RefPtr<AsyncResult>& result, std::string& new_etag);

  /** Finishes an asynchronous replace of the given file . See
   * replace_contents_async(). Sets @a new_etag to the new entity
   * tag for the document.
   * @param result A AsyncResult.
   * for the document.
   */
  void replace_contents_finish(const Glib::RefPtr<AsyncResult>& result);
  _IGNORE(g_file_replace_contents_finish)


 /** Same as replace_contents_async() but takes a Gio::Bytes input instead.
  *
  * When this operation has completed, @a slot will be called
  * and the operation can be finalized with replace_contents_finish().
  *
  * The operation can be cancelled by
  * triggering the cancellable object from another thread. If the operation
  * was cancelled, a Gio::Error with CANCELLED will be thrown.
  *
  * If @a make_backup is true, this function will attempt to
  * make a backup of the file.
  *
  * @param slot: A callback to call when the request is satisfied.
  * @param cancellable A Cancellable object.
  * @param contents Bytes of contents to replace the file with.
  * @param etag a new entity tag for the file.
  * @param make_backup true if a backup should be created.
  * @param flags A set of CreateFlags.
  */
  void replace_contents_bytes_async(const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable, const Glib::RefPtr<const Glib::Bytes>& contents, const std::string& etag, bool make_backup = false, CreateFlags flags = CreateFlags::NONE);

 /** Same as replace_contents_async() but takes a Gio::Bytes input instead.
  *
  * When this operation has completed, @a slot will be called
  * and the operation can be finalized with replace_contents_finish().
  *
  * The operation can be cancelled by
  * triggering the cancellable object from another thread. If the operation
  * was cancelled, a Gio::Error with CANCELLED will be thrown.
  *
  * If @a make_backup is true, this function will attempt to
  * make a backup of the file.
  *
  * @param slot: A callback to call when the request is satisfied.
  * @param contents Bytes of contents to replace the file with.
  * @param etag a new entity tag for the file.
  * @param make_backup true if a backup should be created.
  * @param flags A set of CreateFlags.
  */
  void replace_contents_bytes_async(const SlotAsyncReady& slot, const Glib::RefPtr<const Glib::Bytes>& contents, const std::string& etag, bool make_backup = false, CreateFlags flags = CreateFlags::NONE);

  _IGNORE(g_file_replace_contents_async)

  _WRAP_METHOD(bool supports_thread_contexts() const, g_file_supports_thread_contexts)

protected:
  // *** vfuncs ***

  //_WRAP_VFUNC(Glib::RefPtr<File> dup() const, "dup")
  //_WRAP_VFUNC(guint hash() const, "hash")
  //TODO: equal() vfunc

  //_WRAP_VFUNC(std::string get_basename() const, "get_basename")
  //_WRAP_VFUNC(std::string get_path() const, "get_path")
  //_WRAP_VFUNC(std::string get_uri() const, "get_uri")
  //_WRAP_VFUNC(std::string get_parse_name() const, "get_parse_name")

  //Careful of refcounting: //_WRAP_VFUNC(Glib::RefPtr<File> get_parent() const, "get_parent")

  // GFileIface does not define get_child(). Perhaps it's not intentional.
  //  //_WRAP_VFUNC(Glib::RefPtr<File> get_child(const std::string& name) const, "get_child")

  // howto wrap a vfunc that takes a GError**
//   //_WRAP_VFUNC(Glib::RefPtr<File> get_child_for_display_name(const Glib::ustring& display_name) const,
//               "get_child_for_display_name",
//               errthrow)

#m4 _CONVERSION(`GFile*',`const Glib::RefPtr<const File>&',`Glib::wrap($3, true)')

  //_WRAP_VFUNC(bool has_prefix(const Glib::RefPtr<const File>& prefix) const, "has_prefix")

  //_WRAP_VFUNC(std::string get_relative_path(const Glib::RefPtr<const File>& descendant) const, "get_relative_path")

  //Careful of refcounting:   //_WRAP_VFUNC(Glib::RefPtr<const File> resolve_relative_path(const std::string& relative_path) const, "resolve_relative_path")

  //_WRAP_VFUNC(bool is_native() const, "is_native")
  //_WRAP_VFUNC(bool has_uri_scheme(const std::string& uri_scheme) const, "has_uri_scheme")
};


} // namespace Gio

namespace Glib
{

//Pre-declare this so we can use it in TypeTrait:
GIOMM_API
Glib::RefPtr<Gio::File> wrap(GFile* object, bool take_copy);

namespace Container_Helpers
{

/** This specialization of TypeTraits exists
 * because the default use of Glib::wrap(GObject*),
 * instead of a specific Glib::wrap(GSomeInterface*),
 * would not return a wrapper for an interface.
 */
template <>
struct TypeTraits< Glib::RefPtr<Gio::File> >
{
  using CppType = Glib::RefPtr<Gio::File>;
  using CType = GFile*;
  using CTypeNonConst = GFile*;

  static CType   to_c_type      (const CppType& item)
  { return Glib::unwrap (item); }

  static CppType to_cpp_type    (const CType& item)
  {
    //Use a specific Glib::wrap() function,
    //because CType has the specific type (not just GObject):
    return Glib::wrap(item, true /* take_copy */);
  }

  static void    release_c_type (CType item)
  {
    GLIBMM_DEBUG_UNREFERENCE(nullptr, item);
    g_object_unref(item);
  }
};

} // Container_Helpers
} // Glib