root/trunk/src/gio/DBusConnection.d

/*
 * This file is part of gtkD.
 *
 * gtkD 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 3
 * of the License, or (at your option) any later version, with
 * some exceptions, please read the COPYING file.
 *
 * gtkD 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 gtkD; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
 */
 
// generated automatically - do not change
// find conversion definition on APILookup.txt
// implement new conversion functionalities on the wrap.utils pakage

/*
 * Conversion parameters:
 * inFile  = GDBusConnection.html
 * outPack = gio
 * outFile = DBusConnection
 * strct   = GDBusConnection
 * realStrct=
 * ctorStrct=
 * clss    = DBusConnection
 * interf  = 
 * class Code: Yes
 * interface Code: No
 * template for:
 * extend  = GObject
 * implements:
 *  - InitableIF
 *  - AsyncInitableIF
 * prefixes:
 *  - g_dbus_connection_
 *  - g_dbus_
 * omit structs:
 * omit prefixes:
 * omit code:
 *  - g_dbus_connection_new_finish
 *  - g_dbus_connection_new_for_address_finish
 * omit signals:
 * imports:
 *  - glib.Str
 *  - glib.ErrorG
 *  - glib.GException
 *  - glib.Variant
 *  - glib.VariantType
 *  - gio.AsyncResultIF
 *  - gio.Cancellable
 *  - gio.Credentials
 *  - gio.DBusAuthObserver
 *  - gio.DBusMessage
 *  - gio.DBusMethodInvocation
 *  - gio.IOStream
 *  - gio.InitableT
 *  - gio.InitableIF
 *  - gio.AsyncInitableT
 *  - gio.AsyncInitableIF
 * structWrap:
 *  - GAsyncResult* -> AsyncResultIF
 *  - GCancellable* -> Cancellable
 *  - GCredentials* -> Credentials
 *  - GDBusAuthObserver* -> DBusAuthObserver
 *  - GDBusConnection* -> DBusConnection
 *  - GDBusMessage* -> DBusMessage
 *  - GDBusMethodInvocation* -> DBusMethodInvocation
 *  - GIOStream* -> IOStream
 *  - GVariant* -> Variant
 *  - GVariantType* -> VariantType
 * module aliases:
 * local aliases:
 * overrides:
 */

module gio.DBusConnection;

public  import gtkc.giotypes;

private import gtkc.gio;
private import glib.ConstructionException;

private import gobject.Signals;
public  import gtkc.gdktypes;

private import glib.Str;
private import glib.ErrorG;
private import glib.GException;
private import glib.Variant;
private import glib.VariantType;
private import gio.AsyncResultIF;
private import gio.Cancellable;
private import gio.Credentials;
private import gio.DBusAuthObserver;
private import gio.DBusMessage;
private import gio.DBusMethodInvocation;
private import gio.IOStream;
private import gio.InitableT;
private import gio.InitableIF;
private import gio.AsyncInitableT;
private import gio.AsyncInitableIF;



private import gobject.ObjectG;

/**
 * Description
 * The GDBusConnection type is used for D-Bus connections to remote
 * peers such as a message buses. It is a low-level API that offers a
 * lot of flexibility. For instance, it lets you establish a connection
 * over any transport that can by represented as an GIOStream.
 * This class is rarely used directly in D-Bus clients. If you are writing
 * an D-Bus client, it is often easier to use the g_bus_own_name(),
 * g_bus_watch_name() or g_dbus_proxy_new_for_bus() APIs.
 * $(DDOC_COMMENT example)
 * $(DDOC_COMMENT example)
 * $(DDOC_COMMENT example)
 * $(DDOC_COMMENT example)
 */
public class DBusConnection : ObjectG, InitableIF, AsyncInitableIF
{
    
    /** the main Gtk struct */
    protected GDBusConnection* gDBusConnection;
    
    
    public GDBusConnection* getDBusConnectionStruct()
    {
        return gDBusConnection;
    }
    
    
    /** the main Gtk struct as a void* */
    protected override void* getStruct()
    {
        return cast(void*)gDBusConnection;
    }
    
    /**
     * Sets our main struct and passes it to the parent class
     */
    public this (GDBusConnection* gDBusConnection)
    {
        if(gDBusConnection is null)
        {
            this = null;
            return;
        }
        //Check if there already is a D object for this gtk struct
        void* ptr = getDObject(cast(GObject*)gDBusConnection);
        if( ptr !is null )
        {
            this = cast(DBusConnection)ptr;
            return;
        }
        super(cast(GObject*)gDBusConnection);
        this.gDBusConnection = gDBusConnection;
    }
    
    protected override void setStruct(GObject* obj)
    {
        super.setStruct(obj);
        gDBusConnection = cast(GDBusConnection*)obj;
    }
    
    // add the Initable capabilities
    mixin InitableT!(DBusConnection);
    
    // add the AsyncInitable capabilities
    mixin AsyncInitableT!(DBusConnection);
    
    /**
     * Finishes an operation started with g_dbus_connection_new().
     * Since 2.26
     * Params:
     *      res    = A GAsyncResult obtained from the GAsyncReadyCallback
     *               passed to g_dbus_connection_new().
     *     address = If true finish an address.
     * Throws: GException on failure.
     * Throws: ConstructionException GTK+ fails to create the object.
     */
    public this (AsyncResultIF res, bool address = false)
    {
        // GDBusConnection * g_dbus_connection_new_finish (GAsyncResult *res,  GError **error);
        GError* err = null;
        GDBusConnection* p;
        
        if ( address )
        {
            p = g_dbus_connection_new_for_address_finish((res is null) ? null : res.getAsyncResultTStruct(), &err);
        }
        else
        {
            p = g_dbus_connection_new_finish((res is null) ? null : res.getAsyncResultTStruct(), &err);
        }
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        if(p is null)
        {
            throw new ConstructionException("null returned by g_dbus_connection_new_finish((res is null) ? null : res.getAsyncResultTStruct(), &err)");
        }
        this(cast(GDBusConnection*) p);
    }
    
    /**
     */
    int[string] connectedSignals;
    
    void delegate(gboolean, GError*, DBusConnection)[] onClosedListeners;
    /**
     * Emitted when the connection is closed.
     * The cause of this event can be
     *  If g_dbus_connection_close() is called. In this case
     *  remote_peer_vanished is set to FALSE and error is NULL.
     *  If the remote peer closes the connection. In this case
     *  remote_peer_vanished is set to TRUE and error is set.
     *  If the remote peer sends invalid or malformed data. In this
     *  case remote_peer_vanished is set to FALSE and error
     *  is set.
     * Upon receiving this signal, you should give up your reference to
     * connection. You are guaranteed that this signal is emitted only
     * once.
     * TRUE if connection is closed because the
     * remote peer closed its end of the connection.
     * Since 2.26
     */
    void addOnClosed(void delegate(gboolean, GError*, DBusConnection) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
    {
        if ( !("closed" in connectedSignals) )
        {
            Signals.connectData(
            getStruct(),
            "closed",
            cast(GCallback)&callBackClosed,
            cast(void*)this,
            null,
            connectFlags);
            connectedSignals["closed"] = 1;
        }
        onClosedListeners ~= dlg;
    }
    extern(C) static void callBackClosed(GDBusConnection* connectionStruct, gboolean remotePeerVanished, GError* error, DBusConnection dBusConnection)
    {
        foreach ( void delegate(gboolean, GError*, DBusConnection) dlg ; dBusConnection.onClosedListeners )
        {
            dlg(remotePeerVanished, error, dBusConnection);
        }
    }
    
    
    /**
     * Asynchronously connects to the message bus specified by bus_type.
     * When the operation is finished, callback will be invoked. You can
     * then call g_bus_get_finish() to get the result of the operation.
     * This is a asynchronous failable function. See g_bus_get_sync() for
     * the synchronous version.
     * Since 2.26
     * Params:
     * busType = A GBusType.
     * cancellable = A GCancellable or NULL.
     * callback = A GAsyncReadyCallback to call when the request is satisfied.
     * userData = The data to pass to callback.
     */
    public static void gBusGet(GBusType busType, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
    {
        // void g_bus_get (GBusType bus_type,  GCancellable *cancellable,  GAsyncReadyCallback callback,  gpointer user_data);
        g_bus_get(busType, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
    }
    
    /**
     * Finishes an operation started with g_bus_get().
     * The returned object is a singleton, that is, shared with other
     * callers of g_bus_get() and g_bus_get_sync() for bus_type. In the
     * event that you need a private message bus connection, use
     * g_dbus_address_get_for_bus() and
     * g_dbus_connection_new_for_address().
     * Note that the returned GDBusConnection object will (usually) have
     * the "exit-on-close" property set to TRUE.
     * Since 2.26
     * Params:
     * res = A GAsyncResult obtained from the GAsyncReadyCallback passed to g_bus_get().
     * Returns: A GDBusConnection or NULL if error is set. Free with g_object_unref(). [transfer full]
     * Throws: GException on failure.
     */
    public static DBusConnection gBusGetFinish(AsyncResultIF res)
    {
        // GDBusConnection * g_bus_get_finish (GAsyncResult *res,  GError **error);
        GError* err = null;
        
        auto p = g_bus_get_finish((res is null) ? null : res.getAsyncResultTStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        if(p is null)
        {
            return null;
        }
        return new DBusConnection(cast(GDBusConnection*) p);
    }
    
    /**
     * Synchronously connects to the message bus specified by bus_type.
     * Note that the returned object may shared with other callers,
     * e.g. if two separate parts of a process calls this function with
     * the same bus_type, they will share the same object.
     * This is a synchronous failable function. See g_bus_get() and
     * g_bus_get_finish() for the asynchronous version.
     * The returned object is a singleton, that is, shared with other
     * callers of g_bus_get() and g_bus_get_sync() for bus_type. In the
     * event that you need a private message bus connection, use
     * g_dbus_address_get_for_bus_sync() and
     * g_dbus_connection_new_for_address().
     * Note that the returned GDBusConnection object will (usually) have
     * the "exit-on-close" property set to TRUE.
     * Since 2.26
     * Params:
     * busType = A GBusType.
     * cancellable = A GCancellable or NULL.
     * Returns: A GDBusConnection or NULL if error is set. Free with g_object_unref(). [transfer full]
     * Throws: GException on failure.
     */
    public static DBusConnection gBusGetSync(GBusType busType, Cancellable cancellable)
    {
        // GDBusConnection * g_bus_get_sync (GBusType bus_type,  GCancellable *cancellable,  GError **error);
        GError* err = null;
        
        auto p = g_bus_get_sync(busType, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        if(p is null)
        {
            return null;
        }
        return new DBusConnection(cast(GDBusConnection*) p);
    }
    
    /**
     * Asynchronously sets up a D-Bus connection for exchanging D-Bus messages
     * with the end represented by stream.
     * If observer is not NULL it may be used to control the
     * authentication process.
     * When the operation is finished, callback will be invoked. You can
     * then call g_dbus_connection_new_finish() to get the result of the
     * operation.
     * This is a asynchronous failable constructor. See
     * g_dbus_connection_new_sync() for the synchronous
     * version.
     * Since 2.26
     * Params:
     * stream = A GIOStream.
     * guid = The GUID to use if a authenticating as a server or NULL. [allow-none]
     * flags = Flags describing how to make the connection.
     * observer = A GDBusAuthObserver or NULL. [allow-none]
     * cancellable = A GCancellable or NULL.
     * callback = A GAsyncReadyCallback to call when the request is satisfied.
     * userData = The data to pass to callback.
     */
    public static void newDBusConnection(IOStream stream, string guid, GDBusConnectionFlags flags, DBusAuthObserver observer, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
    {
        // void g_dbus_connection_new (GIOStream *stream,  const gchar *guid,  GDBusConnectionFlags flags,  GDBusAuthObserver *observer,  GCancellable *cancellable,  GAsyncReadyCallback callback,  gpointer user_data);
        g_dbus_connection_new((stream is null) ? null : stream.getIOStreamStruct(), Str.toStringz(guid), flags, (observer is null) ? null : observer.getDBusAuthObserverStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
    }
    
    /**
     * Synchronously sets up a D-Bus connection for exchanging D-Bus messages
     * with the end represented by stream.
     * If observer is not NULL it may be used to control the
     * authentication process.
     * This is a synchronous failable constructor. See
     * g_dbus_connection_new() for the asynchronous version.
     * Since 2.26
     * Params:
     * stream = A GIOStream.
     * guid = The GUID to use if a authenticating as a server or NULL. [allow-none]
     * flags = Flags describing how to make the connection.
     * observer = A GDBusAuthObserver or NULL. [allow-none]
     * cancellable = A GCancellable or NULL.
     * Throws: GException on failure.
     * Throws: ConstructionException GTK+ fails to create the object.
     */
    public this (IOStream stream, string guid, GDBusConnectionFlags flags, DBusAuthObserver observer, Cancellable cancellable)
    {
        // GDBusConnection * g_dbus_connection_new_sync (GIOStream *stream,  const gchar *guid,  GDBusConnectionFlags flags,  GDBusAuthObserver *observer,  GCancellable *cancellable,  GError **error);
        GError* err = null;
        
        auto p = g_dbus_connection_new_sync((stream is null) ? null : stream.getIOStreamStruct(), Str.toStringz(guid), flags, (observer is null) ? null : observer.getDBusAuthObserverStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        if(p is null)
        {
            throw new ConstructionException("null returned by g_dbus_connection_new_sync((stream is null) ? null : stream.getIOStreamStruct(), Str.toStringz(guid), flags, (observer is null) ? null : observer.getDBusAuthObserverStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err)");
        }
        this(cast(GDBusConnection*) p);
    }
    
    /**
     * Asynchronously connects and sets up a D-Bus client connection for
     * exchanging D-Bus messages with an endpoint specified by address
     * which must be in the D-Bus address format.
     * This constructor can only be used to initiate client-side
     * connections - use g_dbus_connection_new() if you need to act as the
     * server. In particular, flags cannot contain the
     * G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER or
     * G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS flags.
     * When the operation is finished, callback will be invoked. You can
     * then call g_dbus_connection_new_finish() to get the result of the
     * operation.
     * If observer is not NULL it may be used to control the
     * authentication process.
     * This is a asynchronous failable constructor. See
     * g_dbus_connection_new_for_address_sync() for the synchronous
     * version.
     * Since 2.26
     * Params:
     * address = A D-Bus address.
     * flags = Flags describing how to make the connection.
     * observer = A GDBusAuthObserver or NULL. [allow-none]
     * cancellable = A GCancellable or NULL.
     * callback = A GAsyncReadyCallback to call when the request is satisfied.
     * userData = The data to pass to callback.
     */
    public static void newForAddress(string address, GDBusConnectionFlags flags, DBusAuthObserver observer, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
    {
        // void g_dbus_connection_new_for_address (const gchar *address,  GDBusConnectionFlags flags,  GDBusAuthObserver *observer,  GCancellable *cancellable,  GAsyncReadyCallback callback,  gpointer user_data);
        g_dbus_connection_new_for_address(Str.toStringz(address), flags, (observer is null) ? null : observer.getDBusAuthObserverStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
    }
    
    /**
     * Synchronously connects and sets up a D-Bus client connection for
     * exchanging D-Bus messages with an endpoint specified by address
     * which must be in the D-Bus address format.
     * This constructor can only be used to initiate client-side
     * connections - use g_dbus_connection_new_sync() if you need to act
     * as the server. In particular, flags cannot contain the
     * G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER or
     * G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS flags.
     * This is a synchronous failable constructor. See
     * g_dbus_connection_new_for_address() for the asynchronous version.
     * If observer is not NULL it may be used to control the
     * authentication process.
     * Since 2.26
     * Params:
     * address = A D-Bus address.
     * flags = Flags describing how to make the connection.
     * observer = A GDBusAuthObserver or NULL. [allow-none]
     * cancellable = A GCancellable or NULL.
     * Throws: GException on failure.
     * Throws: ConstructionException GTK+ fails to create the object.
     */
    public this (string address, GDBusConnectionFlags flags, DBusAuthObserver observer, Cancellable cancellable)
    {
        // GDBusConnection * g_dbus_connection_new_for_address_sync  (const gchar *address,  GDBusConnectionFlags flags,  GDBusAuthObserver *observer,  GCancellable *cancellable,  GError **error);
        GError* err = null;
        
        auto p = g_dbus_connection_new_for_address_sync(Str.toStringz(address), flags, (observer is null) ? null : observer.getDBusAuthObserverStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        if(p is null)
        {
            throw new ConstructionException("null returned by g_dbus_connection_new_for_address_sync(Str.toStringz(address), flags, (observer is null) ? null : observer.getDBusAuthObserverStruct(), (cancellable is null) ? null : cancellable.getCancellableStruct(), &err)");
        }
        this(cast(GDBusConnection*) p);
    }
    
    /**
     * If connection was created with
     * G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING, this method
     * starts processing messages. Does nothing on if connection wasn't
     * created with this flag or if the method has already been called.
     * Since 2.26
     */
    public void startMessageProcessing()
    {
        // void g_dbus_connection_start_message_processing  (GDBusConnection *connection);
        g_dbus_connection_start_message_processing(gDBusConnection);
    }
    
    /**
     * Closes connection. Note that this never causes the process to
     * exit (this might only happen if the other end of a shared message
     * bus connection disconnects, see "exit-on-close").
     * Once the connection is closed, operations such as sending a message
     * will return with the error G_IO_ERROR_CLOSED. Closing a connection
     * will not automatically flush the connection so queued messages may
     * be lost. Use g_dbus_connection_flush() if you need such guarantees.
     * If connection is already closed, this method fails with
     * G_IO_ERROR_CLOSED.
     * When connection has been closed, the "closed"
     * signal is emitted in the thread-default main
     * loop of the thread that connection was constructed in.
     * This is an asynchronous method. When the operation is finished,
     * callback will be invoked in the thread-default main
     * loop of the thread you are calling this method from. You can
     * then call g_dbus_connection_close_finish() to get the result of the
     * operation. See g_dbus_connection_close_sync() for the synchronous
     * version.
     * Since 2.26
     * Params:
     * cancellable = A GCancellable or NULL.
     * callback = A GAsyncReadyCallback to call when the request is
     * satisfied or NULL if you don't care about the result. [allow-none]
     * userData = The data to pass to callback.
     */
    public void close(Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
    {
        // void g_dbus_connection_close (GDBusConnection *connection,  GCancellable *cancellable,  GAsyncReadyCallback callback,  gpointer user_data);
        g_dbus_connection_close(gDBusConnection, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
    }
    
    /**
     * Finishes an operation started with g_dbus_connection_close().
     * Since 2.26
     * Params:
     * res = A GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_connection_close().
     * Returns: TRUE if the operation succeeded, FALSE if error is set.
     * Throws: GException on failure.
     */
    public int closeFinish(AsyncResultIF res)
    {
        // gboolean g_dbus_connection_close_finish (GDBusConnection *connection,  GAsyncResult *res,  GError **error);
        GError* err = null;
        
        auto p = g_dbus_connection_close_finish(gDBusConnection, (res is null) ? null : res.getAsyncResultTStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        return p;
    }
    
    /**
     * Synchronously closees connection. The calling thread is blocked
     * until this is done. See g_dbus_connection_close() for the
     * asynchronous version of this method and more details about what it
     * does.
     * Since 2.26
     * Params:
     * cancellable = A GCancellable or NULL.
     * Returns: TRUE if the operation succeeded, FALSE if error is set.
     * Throws: GException on failure.
     */
    public int closeSync(Cancellable cancellable)
    {
        // gboolean g_dbus_connection_close_sync (GDBusConnection *connection,  GCancellable *cancellable,  GError **error);
        GError* err = null;
        
        auto p = g_dbus_connection_close_sync(gDBusConnection, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        return p;
    }
    
    /**
     * Gets whether connection is closed.
     * Since 2.26
     * Returns: TRUE if the connection is closed, FALSE otherwise.
     */
    public int isClosed()
    {
        // gboolean g_dbus_connection_is_closed (GDBusConnection *connection);
        return g_dbus_connection_is_closed(gDBusConnection);
    }
    
    /**
     * Asynchronously flushes connection, that is, writes all queued
     * outgoing message to the transport and then flushes the transport
     * (using g_output_stream_flush_async()). This is useful in programs
     * that wants to emit a D-Bus signal and then exit
     * immediately. Without flushing the connection, there is no guarantee
     * that the message has been sent to the networking buffers in the OS
     * kernel.
     * This is an asynchronous method. When the operation is finished,
     * callback will be invoked in the thread-default main
     * loop of the thread you are calling this method from. You can
     * then call g_dbus_connection_flush_finish() to get the result of the
     * operation. See g_dbus_connection_flush_sync() for the synchronous
     * version.
     * Since 2.26
     * Params:
     * cancellable = A GCancellable or NULL.
     * callback = A GAsyncReadyCallback to call when the request is
     * satisfied or NULL if you don't care about the result. [allow-none]
     * userData = The data to pass to callback.
     */
    public void flush(Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
    {
        // void g_dbus_connection_flush (GDBusConnection *connection,  GCancellable *cancellable,  GAsyncReadyCallback callback,  gpointer user_data);
        g_dbus_connection_flush(gDBusConnection, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
    }
    
    /**
     * Finishes an operation started with g_dbus_connection_flush().
     * Since 2.26
     * Params:
     * res = A GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_connection_flush().
     * Returns: TRUE if the operation succeeded, FALSE if error is set.
     * Throws: GException on failure.
     */
    public int flushFinish(AsyncResultIF res)
    {
        // gboolean g_dbus_connection_flush_finish (GDBusConnection *connection,  GAsyncResult *res,  GError **error);
        GError* err = null;
        
        auto p = g_dbus_connection_flush_finish(gDBusConnection, (res is null) ? null : res.getAsyncResultTStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        return p;
    }
    
    /**
     * Synchronously flushes connection. The calling thread is blocked
     * until this is done. See g_dbus_connection_flush() for the
     * asynchronous version of this method and more details about what it
     * does.
     * Since 2.26
     * Params:
     * cancellable = A GCancellable or NULL.
     * Returns: TRUE if the operation succeeded, FALSE if error is set.
     * Throws: GException on failure.
     */
    public int flushSync(Cancellable cancellable)
    {
        // gboolean g_dbus_connection_flush_sync (GDBusConnection *connection,  GCancellable *cancellable,  GError **error);
        GError* err = null;
        
        auto p = g_dbus_connection_flush_sync(gDBusConnection, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        return p;
    }
    
    /**
     * Gets whether the process is terminated when connection is
     * closed by the remote peer. See
     * "exit-on-close" for more details.
     * Since 2.26
     * Returns: Whether the process is terminated when connection is closed by the remote peer.
     */
    public int getExitOnClose()
    {
        // gboolean g_dbus_connection_get_exit_on_close (GDBusConnection *connection);
        return g_dbus_connection_get_exit_on_close(gDBusConnection);
    }
    
    /**
     * Sets whether the process should be terminated when connection is
     * closed by the remote peer. See "exit-on-close" for
     * more details.
     * Note that this function should be used with care. Most modern UNIX
     * desktops tie the notion of a user session the session bus, and expect
     * all of a users applications to quit when their bus connection goes away.
     * If you are setting exit_on_close to FALSE for the shared session
     * bus connection, you should make sure that your application exits
     * when the user session ends.
     * Since 2.26
     * Params:
     * exitOnClose = Whether the process should be terminated
     * when connection is closed by the remote peer.
     */
    public void setExitOnClose(int exitOnClose)
    {
        // void g_dbus_connection_set_exit_on_close (GDBusConnection *connection,  gboolean exit_on_close);
        g_dbus_connection_set_exit_on_close(gDBusConnection, exitOnClose);
    }
    
    /**
     * Gets the underlying stream used for IO.
     * Since 2.26
     * Returns: the stream used for IO. [transfer none]
     */
    public IOStream getStream()
    {
        // GIOStream * g_dbus_connection_get_stream (GDBusConnection *connection);
        auto p = g_dbus_connection_get_stream(gDBusConnection);
        if(p is null)
        {
            return null;
        }
        return new IOStream(cast(GIOStream*) p);
    }
    
    /**
     * The GUID of the peer performing the role of server when
     * authenticating. See "guid" for more details.
     * Since 2.26
     * Returns: The GUID. Do not free this string, it is owned by connection.
     */
    public string getGuid()
    {
        // const gchar * g_dbus_connection_get_guid (GDBusConnection *connection);
        return Str.toString(g_dbus_connection_get_guid(gDBusConnection));
    }
    
    /**
     * Gets the unique name of connection as assigned by the message
     * bus. This can also be used to figure out if connection is a
     * message bus connection.
     * Since 2.26
     * Returns: The unique name or NULL if connection is not a message bus connection. Do not free this string, it is owned by connection.
     */
    public string getUniqueName()
    {
        // const gchar * g_dbus_connection_get_unique_name (GDBusConnection *connection);
        return Str.toString(g_dbus_connection_get_unique_name(gDBusConnection));
    }
    
    /**
     * Gets the capabilities negotiated with the remote peer
     * Since 2.26
     * Returns: Zero or more flags from the GDBusCapabilityFlags enumeration.
     */
    public GDBusCapabilityFlags getCapabilities()
    {
        // GDBusCapabilityFlags g_dbus_connection_get_capabilities  (GDBusConnection *connection);
        return g_dbus_connection_get_capabilities(gDBusConnection);
    }
    
    /**
     * Gets the credentials of the authenticated peer. This will always
     * return NULL unless connection acted as a server
     * (e.g. G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER was passed)
     * when set up and the client passed credentials as part of the
     * authentication process.
     * In a message bus setup, the message bus is always the server and
     * each application is a client. So this method will always return
     * NULL for message bus clients.
     * Since 2.26
     * Returns: A GCredentials or NULL if not available. Do not free this object, it is owned by connection. [transfer none]
     */
    public Credentials getPeerCredentials()
    {
        // GCredentials * g_dbus_connection_get_peer_credentials  (GDBusConnection *connection);
        auto p = g_dbus_connection_get_peer_credentials(gDBusConnection);
        if(p is null)
        {
            return null;
        }
        return new Credentials(cast(GCredentials*) p);
    }
    
    /**
     * Asynchronously invokes the method_name method on the
     * interface_name D-Bus interface on the remote object at
     * object_path owned by bus_name.
     * If connection is closed then the operation will fail with
     * G_IO_ERROR_CLOSED. If cancellable is canceled, the operation will
     * fail with G_IO_ERROR_CANCELLED. If parameters contains a value
     * not compatible with the D-Bus protocol, the operation fails with
     * G_IO_ERROR_INVALID_ARGUMENT.
     * If reply_type is non-NULL then the reply will be checked for having this type and an
     * error will be raised if it does not match. Said another way, if you give a reply_type
     * then any non-NULL return value will be of this type.
     * If the parameters GVariant is floating, it is consumed. This allows
     * Since 2.26
     * Params:
     * busName = A unique or well-known bus name or NULL if
     * connection is not a message bus connection. [allow-none]
     * objectPath = Path of remote object.
     * interfaceName = D-Bus interface to invoke method on.
     * methodName = The name of the method to invoke.
     * parameters = A GVariant tuple with parameters for the method
     * or NULL if not passing parameters. [allow-none]
     * replyType = The expected type of the reply, or NULL. [allow-none]
     * flags = Flags from the GDBusCallFlags enumeration.
     * timeoutMsec = The timeout in milliseconds, -1 to use the default
     * timeout or G_MAXINT for no timeout.
     * cancellable = A GCancellable or NULL.
     * callback = A GAsyncReadyCallback to call when the request is
     * satisfied or NULL if you don't * care about the result of the
     * method invocation. [allow-none]
     * userData = The data to pass to callback.
     */
    public void call(string busName, string objectPath, string interfaceName, string methodName, Variant parameters, VariantType replyType, GDBusCallFlags flags, int timeoutMsec, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
    {
        // void g_dbus_connection_call (GDBusConnection *connection,  const gchar *bus_name,  const gchar *object_path,  const gchar *interface_name,  const gchar *method_name,  GVariant *parameters,  const GVariantType *reply_type,  GDBusCallFlags flags,  gint timeout_msec,  GCancellable *cancellable,  GAsyncReadyCallback callback,  gpointer user_data);
        g_dbus_connection_call(gDBusConnection, Str.toStringz(busName), Str.toStringz(objectPath), Str.toStringz(interfaceName), Str.toStringz(methodName), (parameters is null) ? null : parameters.getVariantStruct(), (replyType is null) ? null : replyType.getVariantTypeStruct(), flags, timeoutMsec, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
    }
    
    /**
     * Finishes an operation started with g_dbus_connection_call().
     * Since 2.26
     * Params:
     * res = A GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_connection_call().
     * Returns: NULL if error is set. Otherwise a GVariant tuple with return values. Free with g_variant_unref().
     * Throws: GException on failure.
     */
    public Variant callFinish(AsyncResultIF res)
    {
        // GVariant * g_dbus_connection_call_finish (GDBusConnection *connection,  GAsyncResult *res,  GError **error);
        GError* err = null;
        
        auto p = g_dbus_connection_call_finish(gDBusConnection, (res is null) ? null : res.getAsyncResultTStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        if(p is null)
        {
            return null;
        }
        return new Variant(cast(GVariant*) p);
    }
    
    /**
     * Synchronously invokes the method_name method on the
     * interface_name D-Bus interface on the remote object at
     * object_path owned by bus_name.
     * If connection is closed then the operation will fail with
     * G_IO_ERROR_CLOSED. If cancellable is canceled, the
     * operation will fail with G_IO_ERROR_CANCELLED. If parameters
     * contains a value not compatible with the D-Bus protocol, the operation
     * fails with G_IO_ERROR_INVALID_ARGUMENT.
     * If reply_type is non-NULL then the reply will be checked for having
     * this type and an error will be raised if it does not match. Said
     * another way, if you give a reply_type then any non-NULL return
     * value will be of this type.
     * If the parameters GVariant is floating, it is consumed.
     * Since 2.26
     * Params:
     * busName = A unique or well-known bus name.
     * objectPath = Path of remote object.
     * interfaceName = D-Bus interface to invoke method on.
     * methodName = The name of the method to invoke.
     * parameters = A GVariant tuple with parameters for the method
     * or NULL if not passing parameters. [allow-none]
     * replyType = The expected type of the reply, or NULL. [allow-none]
     * flags = Flags from the GDBusCallFlags enumeration.
     * timeoutMsec = The timeout in milliseconds, -1 to use the default
     * timeout or G_MAXINT for no timeout.
     * cancellable = A GCancellable or NULL.
     * Returns: NULL if error is set. Otherwise a GVariant tuple with return values. Free with g_variant_unref().
     * Throws: GException on failure.
     */
    public Variant callSync(string busName, string objectPath, string interfaceName, string methodName, Variant parameters, VariantType replyType, GDBusCallFlags flags, int timeoutMsec, Cancellable cancellable)
    {
        // GVariant * g_dbus_connection_call_sync (GDBusConnection *connection,  const gchar *bus_name,  const gchar *object_path,  const gchar *interface_name,  const gchar *method_name,  GVariant *parameters,  const GVariantType *reply_type,  GDBusCallFlags flags,  gint timeout_msec,  GCancellable *cancellable,  GError **error);
        GError* err = null;
        
        auto p = g_dbus_connection_call_sync(gDBusConnection, Str.toStringz(busName), Str.toStringz(objectPath), Str.toStringz(interfaceName), Str.toStringz(methodName), (parameters is null) ? null : parameters.getVariantStruct(), (replyType is null) ? null : replyType.getVariantTypeStruct(), flags, timeoutMsec, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        if(p is null)
        {
            return null;
        }
        return new Variant(cast(GVariant*) p);
    }
    
    /**
     * Emits a signal.
     * If the parameters GVariant is floating, it is consumed.
     * This can only fail if parameters is not compatible with the D-Bus protocol.
     * Since 2.26
     * Params:
     * destinationBusName = The unique bus name for the destination
     * for the signal or NULL to emit to all listeners. [allow-none]
     * objectPath = Path of remote object.
     * interfaceName = D-Bus interface to emit a signal on.
     * signalName = The name of the signal to emit.
     * parameters = A GVariant tuple with parameters for the signal
     * or NULL if not passing parameters. [allow-none]
     * Returns: TRUE unless error is set.
     * Throws: GException on failure.
     */
    public int emitSignal(string destinationBusName, string objectPath, string interfaceName, string signalName, Variant parameters)
    {
        // gboolean g_dbus_connection_emit_signal (GDBusConnection *connection,  const gchar *destination_bus_name,  const gchar *object_path,  const gchar *interface_name,  const gchar *signal_name,  GVariant *parameters,  GError **error);
        GError* err = null;
        
        auto p = g_dbus_connection_emit_signal(gDBusConnection, Str.toStringz(destinationBusName), Str.toStringz(objectPath), Str.toStringz(interfaceName), Str.toStringz(signalName), (parameters is null) ? null : parameters.getVariantStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        return p;
    }
    
    /**
     * Subscribes to signals on connection and invokes callback with a
     * whenever the signal is received. Note that callback
     * will be invoked in the thread-default main
     * loop of the thread you are calling this method from.
     * If connection is not a message bus connection, sender must be
     * NULL.
     * If sender is a well-known name note that callback is invoked with
     * the unique name for the owner of sender, not the well-known name
     * as one would expect. This is because the message bus rewrites the
     * name. As such, to avoid certain race conditions, users should be
     * tracking the name owner of the well-known name and use that when
     * processing the received signal.
     * Since 2.26
     * Params:
     * sender = Sender name to match on (unique or well-known name)
     * or NULL to listen from all senders. [allow-none]
     * interfaceName = D-Bus interface name to match on or NULL to
     * match on all interfaces. [allow-none]
     * member = D-Bus signal name to match on or NULL to match on all signals. [allow-none]
     * objectPath = Object path to match on or NULL to match on all object paths. [allow-none]
     * arg0 = Contents of first string argument to match on or NULL
     * to match on all kinds of arguments. [allow-none]
     * flags = Flags describing how to subscribe to the signal (currently unused).
     * callback = Callback to invoke when there is a signal matching the requested data.
     * userData = User data to pass to callback.
     * userDataFreeFunc = Function to free user_data with when subscription is removed or NULL.
     * Returns: A subscription identifier that can be used with g_dbus_connection_signal_unsubscribe().
     */
    public uint signalSubscribe(string sender, string interfaceName, string member, string objectPath, string arg0, GDBusSignalFlags flags, GDBusSignalCallback callback, void* userData, GDestroyNotify userDataFreeFunc)
    {
        // guint g_dbus_connection_signal_subscribe (GDBusConnection *connection,  const gchar *sender,  const gchar *interface_name,  const gchar *member,  const gchar *object_path,  const gchar *arg0,  GDBusSignalFlags flags,  GDBusSignalCallback callback,  gpointer user_data,  GDestroyNotify user_data_free_func);
        return g_dbus_connection_signal_subscribe(gDBusConnection, Str.toStringz(sender), Str.toStringz(interfaceName), Str.toStringz(member), Str.toStringz(objectPath), Str.toStringz(arg0), flags, callback, userData, userDataFreeFunc);
    }
    
    /**
     * Unsubscribes from signals.
     * Since 2.26
     * Params:
     * subscriptionId = A subscription id obtained from g_dbus_connection_signal_subscribe().
     */
    public void signalUnsubscribe(uint subscriptionId)
    {
        // void g_dbus_connection_signal_unsubscribe  (GDBusConnection *connection,  guint subscription_id);
        g_dbus_connection_signal_unsubscribe(gDBusConnection, subscriptionId);
    }
    
    /**
     * Asynchronously sends message to the peer represented by connection.
     * Unless flags contain the
     * G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number
     * will be assigned by connection and set on message via
     * g_dbus_message_set_serial(). If out_serial is not NULL, then the
     * serial number used will be written to this location prior to
     * submitting the message to the underlying transport.
     * If connection is closed then the operation will fail with
     * G_IO_ERROR_CLOSED. If message is not well-formed,
     * the operation fails with G_IO_ERROR_INVALID_ARGUMENT.
     * See Example 2, “D-Bus server example” and Example 4, “D-Bus UNIX File Descriptor example” for an example of how to use this
     * low-level API to send and receive UNIX file descriptors.
     * Note that message must be unlocked, unless flags contain the
     * G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
     * Since 2.26
     * Params:
     * message = A GDBusMessage
     * flags = Flags affecting how the message is sent.
     * outSerial = Return location for serial number assigned
     * to message when sending it or NULL. [out][allow-none]
     * Returns: TRUE if the message was well-formed and queued for transmission, FALSE if error is set.
     * Throws: GException on failure.
     */
    public int sendMessage(DBusMessage message, GDBusSendMessageFlags flags, out uint outSerial)
    {
        // gboolean g_dbus_connection_send_message (GDBusConnection *connection,  GDBusMessage *message,  GDBusSendMessageFlags flags,  volatile guint32 *out_serial,  GError **error);
        GError* err = null;
        
        auto p = g_dbus_connection_send_message(gDBusConnection, (message is null) ? null : message.getDBusMessageStruct(), flags, &outSerial, &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        return p;
    }
    
    /**
     * Asynchronously sends message to the peer represented by connection.
     * Unless flags contain the
     * G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number
     * will be assigned by connection and set on message via
     * g_dbus_message_set_serial(). If out_serial is not NULL, then the
     * serial number used will be written to this location prior to
     * submitting the message to the underlying transport.
     * If connection is closed then the operation will fail with
     * G_IO_ERROR_CLOSED. If cancellable is canceled, the operation will
     * fail with G_IO_ERROR_CANCELLED. If message is not well-formed,
     * the operation fails with G_IO_ERROR_INVALID_ARGUMENT.
     * This is an asynchronous method. When the operation is finished, callback will be invoked
     * in the thread-default main loop
     * of the thread you are calling this method from. You can then call
     * g_dbus_connection_send_message_with_reply_finish() to get the result of the operation.
     * See g_dbus_connection_send_message_with_reply_sync() for the synchronous version.
     * Note that message must be unlocked, unless flags contain the
     * G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
     * See Example 2, “D-Bus server example” and Example 4, “D-Bus UNIX File Descriptor example” for an example of how to use this
     * low-level API to send and receive UNIX file descriptors.
     * Since 2.26
     * Params:
     * message = A GDBusMessage.
     * flags = Flags affecting how the message is sent.
     * timeoutMsec = The timeout in milliseconds, -1 to use the default
     * timeout or G_MAXINT for no timeout.
     * outSerial = Return location for serial number assigned
     * to message when sending it or NULL. [out][allow-none]
     * cancellable = A GCancellable or NULL.
     * callback = A GAsyncReadyCallback to call when the request is
     * satisfied or NULL if you don't care about the result. [allow-none]
     * userData = The data to pass to callback.
     */
    public void sendMessageWithReply(DBusMessage message, GDBusSendMessageFlags flags, int timeoutMsec, out uint outSerial, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
    {
        // void g_dbus_connection_send_message_with_reply  (GDBusConnection *connection,  GDBusMessage *message,  GDBusSendMessageFlags flags,  gint timeout_msec,  volatile guint32 *out_serial,  GCancellable *cancellable,  GAsyncReadyCallback callback,  gpointer user_data);
        g_dbus_connection_send_message_with_reply(gDBusConnection, (message is null) ? null : message.getDBusMessageStruct(), flags, timeoutMsec, &outSerial, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
    }
    
    /**
     * Finishes an operation started with g_dbus_connection_send_message_with_reply().
     * Note that error is only set if a local in-process error
     * occured. That is to say that the returned GDBusMessage object may
     * be of type G_DBUS_MESSAGE_TYPE_ERROR. Use
     * g_dbus_message_to_gerror() to transcode this to a GError.
     * See Example 2, “D-Bus server example” and Example 4, “D-Bus UNIX File Descriptor example” for an example of how to use this
     * low-level API to send and receive UNIX file descriptors.
     * Since 2.26
     * Params:
     * res = A GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_connection_send_message_with_reply().
     * Returns: A locked GDBusMessage or NULL if error is set. [transfer full]
     * Throws: GException on failure.
     */
    public DBusMessage sendMessageWithReplyFinish(AsyncResultIF res)
    {
        // GDBusMessage * g_dbus_connection_send_message_with_reply_finish  (GDBusConnection *connection,  GAsyncResult *res,  GError **error);
        GError* err = null;
        
        auto p = g_dbus_connection_send_message_with_reply_finish(gDBusConnection, (res is null) ? null : res.getAsyncResultTStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        if(p is null)
        {
            return null;
        }
        return new DBusMessage(cast(GDBusMessage*) p);
    }
    
    /**
     * Synchronously sends message to the peer represented by connection
     * and blocks the calling thread until a reply is received or the
     * timeout is reached. See g_dbus_connection_send_message_with_reply()
     * for the asynchronous version of this method.
     * Unless flags contain the
     * G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number
     * will be assigned by connection and set on message via
     * g_dbus_message_set_serial(). If out_serial is not NULL, then the
     * serial number used will be written to this location prior to
     * submitting the message to the underlying transport.
     * If connection is closed then the operation will fail with
     * G_IO_ERROR_CLOSED. If cancellable is canceled, the operation will
     * fail with G_IO_ERROR_CANCELLED. If message is not well-formed,
     * the operation fails with G_IO_ERROR_INVALID_ARGUMENT.
     * Note that error is only set if a local in-process error
     * occured. That is to say that the returned GDBusMessage object may
     * be of type G_DBUS_MESSAGE_TYPE_ERROR. Use
     * g_dbus_message_to_gerror() to transcode this to a GError.
     * See Example 2, “D-Bus server example” and Example 4, “D-Bus UNIX File Descriptor example” for an example of how to use this
     * low-level API to send and receive UNIX file descriptors.
     * Note that message must be unlocked, unless flags contain the
     * G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
     * Since 2.26
     * Params:
     * message = A GDBusMessage.
     * flags = Flags affecting how the message is sent.
     * timeoutMsec = The timeout in milliseconds, -1 to use the default
     * timeout or G_MAXINT for no timeout.
     * outSerial = Return location for serial number assigned
     * to message when sending it or NULL. [out][allow-none]
     * cancellable = A GCancellable or NULL.
     * Returns: A locked GDBusMessage that is the reply to message or NULL if error is set. [transfer full]
     * Throws: GException on failure.
     */
    public DBusMessage sendMessageWithReplySync(DBusMessage message, GDBusSendMessageFlags flags, int timeoutMsec, out uint outSerial, Cancellable cancellable)
    {
        // GDBusMessage * g_dbus_connection_send_message_with_reply_sync  (GDBusConnection *connection,  GDBusMessage *message,  GDBusSendMessageFlags flags,  gint timeout_msec,  volatile guint32 *out_serial,  GCancellable *cancellable,  GError **error);
        GError* err = null;
        
        auto p = g_dbus_connection_send_message_with_reply_sync(gDBusConnection, (message is null) ? null : message.getDBusMessageStruct(), flags, timeoutMsec, &outSerial, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        if(p is null)
        {
            return null;
        }
        return new DBusMessage(cast(GDBusMessage*) p);
    }
    
    /**
     * Adds a message filter. Filters are handlers that are run on all
     * incoming and outgoing messages, prior to standard dispatch. Filters
     * are run in the order that they were added. The same handler can be
     * added as a filter more than once, in which case it will be run more
     * than once. Filters added during a filter callback won't be run on
     * the message being processed. Filter functions are allowed to modify
     * and even drop messages - see the GDBusMessageFilterResult
     * enumeration for details.
     * Note that filters are run in a dedicated message handling thread so
     * they can't block and, generally, can't do anything but signal a
     * worker thread. Also note that filters are rarely needed - use API
     * such as g_dbus_connection_send_message_with_reply(),
     * g_dbus_connection_signal_subscribe() or
     * g_dbus_connection_call() instead.
     * If a filter consumes an incoming message the message is not
     * dispatched anywhere else - not even the standard dispatch machinery
     * (that API such as g_dbus_connection_signal_subscribe() and
     * g_dbus_connection_send_message_with_reply() relies on) will see the
     * message. Similary, if a filter consumes an outgoing message, the
     * message will not be sent to the other peer.
     * Since 2.26
     * Params:
     * filterFunction = A filter function.
     * userData = User data to pass to filter_function.
     * userDataFreeFunc = Function to free user_data with when filter
     * is removed or NULL.
     * Returns: A filter identifier that can be used with g_dbus_connection_remove_filter().
     */
    public uint addFilter(GDBusMessageFilterFunction filterFunction, void* userData, GDestroyNotify userDataFreeFunc)
    {
        // guint g_dbus_connection_add_filter (GDBusConnection *connection,  GDBusMessageFilterFunction filter_function,  gpointer user_data,  GDestroyNotify user_data_free_func);
        return g_dbus_connection_add_filter(gDBusConnection, filterFunction, userData, userDataFreeFunc);
    }
    
    /**
     * Removes a filter.
     * Since 2.26
     * Params:
     * filterId = an identifier obtained from g_dbus_connection_add_filter()
     */
    public void removeFilter(uint filterId)
    {
        // void g_dbus_connection_remove_filter (GDBusConnection *connection,  guint filter_id);
        g_dbus_connection_remove_filter(gDBusConnection, filterId);
    }
    
    /**
     * Registers callbacks for exported objects at object_path with the
     * D-Bus interface that is described in interface_info.
     * Calls to functions in vtable (and user_data_free_func) will
     * happen in the thread-default main
     * loop of the thread you are calling this method from.
     * Note that all GVariant values passed to functions in vtable will match
     * the signature given in interface_info - if a remote caller passes
     * incorrect values, the org.freedesktop.DBus.Error.InvalidArgs
     * is returned to the remote caller.
     * Additionally, if the remote caller attempts to invoke methods or
     * access properties not mentioned in interface_info the
     * org.freedesktop.DBus.Error.UnknownMethod resp.
     * org.freedesktop.DBus.Error.InvalidArgs errors
     * are returned to the caller.
     * It is considered a programming error if the
     * GDBusInterfaceGetPropertyFunc function in vtable returns a
     * GVariant of incorrect type.
     * If an existing callback is already registered at object_path and
     * interface_name, then error is set to G_IO_ERROR_EXISTS.
     * GDBus automatically implements the standard D-Bus interfaces
     * org.freedesktop.DBus.Properties, org.freedesktop.DBus.Introspectable
     * and org.freedesktop.Peer, so you don't have to implement those for
     * the objects you export. You can implement
     * org.freedesktop.DBus.Properties yourself, e.g. to handle getting
     * and setting of properties asynchronously.
     * Note that the reference count on interface_info will be
     * incremented by 1 (unless allocated statically, e.g. if the
     * reference count is -1, see g_dbus_interface_info_ref()) for as long
     * as the object is exported. Also note that vtable will be copied.
     * A NULL vtable can be used for
     * marker
     * interfaces.
     * See Example 2, “D-Bus server example” for an example of how to use this
     * method.
     * Since 2.26
     * Params:
     * objectPath = The object path to register at
     * interfaceInfo = Introspection data for the interface
     * vtable = A GDBusInterfaceVTable to call into, or NULL. [allow-none]
     * userData = Data to pass to functions in vtable
     * userDataFreeFunc = Function to call when the object path is unregistered
     * Returns: 0 if error is set, otherwise a registration id (never 0) that can be used with g_dbus_connection_unregister_object() .
     * Throws: GException on failure.
     */
    public uint registerObject(string objectPath, GDBusInterfaceInfo* interfaceInfo, GDBusInterfaceVTable* vtable, void* userData, GDestroyNotify userDataFreeFunc)
    {
        // guint g_dbus_connection_register_object (GDBusConnection *connection,  const gchar *object_path,  GDBusInterfaceInfo *interface_info,  const GDBusInterfaceVTable *vtable,  gpointer user_data,  GDestroyNotify user_data_free_func,  GError **error);
        GError* err = null;
        
        auto p = g_dbus_connection_register_object(gDBusConnection, Str.toStringz(objectPath), interfaceInfo, vtable, userData, userDataFreeFunc, &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        return p;
    }
    
    /**
     * Unregisters an object.
     * Since 2.26
     * Params:
     * registrationId = A registration id obtained from g_dbus_connection_register_object().
     * Returns: TRUE if the object was unregistered, FALSE otherwise.
     */
    public int unregisterObject(uint registrationId)
    {
        // gboolean g_dbus_connection_unregister_object (GDBusConnection *connection,  guint registration_id);
        return g_dbus_connection_unregister_object(gDBusConnection, registrationId);
    }
    
    /**
     * Registers a whole subtree of “dynamic” objects.
     * The enumerate and introspection functions in vtable are used to
     * convey, to remote callers, what nodes exist in the subtree rooted
     * by object_path.
     * When handling remote calls into any node in the subtree, first the
     * enumerate function is used to check if the node exists. If the node exists
     * or the G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag is set
     * the introspection function is used to check if the node supports the
     * requested method. If so, the dispatch function is used to determine
     * where to dispatch the call. The collected GDBusInterfaceVTable and
     * gpointer will be used to call into the interface vtable for processing
     * the request.
     * All calls into user-provided code will be invoked in the thread-default main
     * loop of the thread you are calling this method from.
     * If an existing subtree is already registered at object_path or
     * then error is set to G_IO_ERROR_EXISTS.
     * Note that it is valid to register regular objects (using
     * g_dbus_connection_register_object()) in a subtree registered with
     * g_dbus_connection_register_subtree() - if so, the subtree handler
     * is tried as the last resort. One way to think about a subtree
     * handler is to consider it a “fallback handler”
     * for object paths not registered via g_dbus_connection_register_object()
     * or other bindings.
     * Note that vtable will be copied so you cannot change it after
     * registration.
     * See Example 3, “D-Bus subtree example” for an example of how to use this method.
     * Since 2.26
     * Params:
     * objectPath = The object path to register the subtree at.
     * vtable = A GDBusSubtreeVTable to enumerate, introspect and dispatch nodes in the subtree.
     * flags = Flags used to fine tune the behavior of the subtree.
     * userData = Data to pass to functions in vtable.
     * userDataFreeFunc = Function to call when the subtree is unregistered.
     * Returns: 0 if error is set, otherwise a subtree registration id (never 0) that can be used with g_dbus_connection_unregister_subtree() .
     * Throws: GException on failure.
     */
    public uint registerSubtree(string objectPath, GDBusSubtreeVTable* vtable, GDBusSubtreeFlags flags, void* userData, GDestroyNotify userDataFreeFunc)
    {
        // guint g_dbus_connection_register_subtree (GDBusConnection *connection,  const gchar *object_path,  const GDBusSubtreeVTable *vtable,  GDBusSubtreeFlags flags,  gpointer user_data,  GDestroyNotify user_data_free_func,  GError **error);
        GError* err = null;
        
        auto p = g_dbus_connection_register_subtree(gDBusConnection, Str.toStringz(objectPath), vtable, flags, userData, userDataFreeFunc, &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        return p;
    }
    
    /**
     * Unregisters a subtree.
     * Since 2.26
     * Params:
     * registrationId = A subtree registration id obtained from g_dbus_connection_register_subtree().
     * Returns: TRUE if the subtree was unregistered, FALSE otherwise.
     */
    public int unregisterSubtree(uint registrationId)
    {
        // gboolean g_dbus_connection_unregister_subtree  (GDBusConnection *connection,  guint registration_id);
        return g_dbus_connection_unregister_subtree(gDBusConnection, registrationId);
    }
}