root/trunk/src/gio/Resolver.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  = GResolver.html
 * outPack = gio
 * outFile = Resolver
 * strct   = GResolver
 * realStrct=
 * ctorStrct=
 * clss    = Resolver
 * interf  = 
 * class Code: No
 * interface Code: No
 * template for:
 * extend  = 
 * implements:
 * prefixes:
 *  - g_resolver_
 * omit structs:
 * omit prefixes:
 * omit code:
 * omit signals:
 * imports:
 *  - glib.Str
 *  - glib.ErrorG
 *  - glib.GException
 *  - glib.ListG
 *  - gio.AsyncResultIF
 *  - gio.Cancellable
 * structWrap:
 *  - GAsyncResult* -> AsyncResultIF
 *  - GCancellable* -> Cancellable
 *  - GList* -> ListG
 *  - GResolver* -> Resolver
 * module aliases:
 * local aliases:
 * overrides:
 */

module gio.Resolver;

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.ListG;
private import gio.AsyncResultIF;
private import gio.Cancellable;



private import gobject.ObjectG;

/**
 * Description
 * GResolver provides cancellable synchronous and asynchronous DNS
 * resolution, for hostnames (g_resolver_lookup_by_address(),
 * g_resolver_lookup_by_name() and their async variants) and SRV
 * (service) records (g_resolver_lookup_service()).
 * GNetworkAddress and GNetworkService provide wrappers around
 * GResolver functionality that also implement GSocketConnectable,
 * making it easy to connect to a remote host/service.
 */
public class Resolver : ObjectG
{
    
    /** the main Gtk struct */
    protected GResolver* gResolver;
    
    
    public GResolver* getResolverStruct()
    {
        return gResolver;
    }
    
    
    /** the main Gtk struct as a void* */
    protected override void* getStruct()
    {
        return cast(void*)gResolver;
    }
    
    /**
     * Sets our main struct and passes it to the parent class
     */
    public this (GResolver* gResolver)
    {
        if(gResolver is null)
        {
            this = null;
            return;
        }
        //Check if there already is a D object for this gtk struct
        void* ptr = getDObject(cast(GObject*)gResolver);
        if( ptr !is null )
        {
            this = cast(Resolver)ptr;
            return;
        }
        super(cast(GObject*)gResolver);
        this.gResolver = gResolver;
    }
    
    protected override void setStruct(GObject* obj)
    {
        super.setStruct(obj);
        gResolver = cast(GResolver*)obj;
    }
    
    /**
     */
    int[string] connectedSignals;
    
    void delegate(Resolver)[] onReloadListeners;
    /**
     * Emitted when the resolver notices that the system resolver
     * configuration has changed.
     */
    void addOnReload(void delegate(Resolver) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
    {
        if ( !("reload" in connectedSignals) )
        {
            Signals.connectData(
            getStruct(),
            "reload",
            cast(GCallback)&callBackReload,
            cast(void*)this,
            null,
            connectFlags);
            connectedSignals["reload"] = 1;
        }
        onReloadListeners ~= dlg;
    }
    extern(C) static void callBackReload(GResolver* resolverStruct, Resolver resolver)
    {
        foreach ( void delegate(Resolver) dlg ; resolver.onReloadListeners )
        {
            dlg(resolver);
        }
    }
    
    
    /**
     * Gets the default GResolver. You should unref it when you are done
     * with it. GResolver may use its reference count as a hint about how
     * many threads/processes, etc it should allocate for concurrent DNS
     * resolutions.
     * Since 2.22
     * Returns: the default GResolver. [transfer full]
     */
    public static Resolver getDefault()
    {
        // GResolver * g_resolver_get_default (void);
        auto p = g_resolver_get_default();
        if(p is null)
        {
            return null;
        }
        return new Resolver(cast(GResolver*) p);
    }
    
    /**
     * Sets resolver to be the application's default resolver (reffing
     * resolver, and unreffing the previous default resolver, if any).
     * Future calls to g_resolver_get_default() will return this resolver.
     * This can be used if an application wants to perform any sort of DNS
     * caching or "pinning"; it can implement its own GResolver that
     * calls the original default resolver for DNS operations, and
     * implements its own cache policies on top of that, and then set
     * itself as the default resolver for all later code to use.
     * Since 2.22
     */
    public void setDefault()
    {
        // void g_resolver_set_default (GResolver *resolver);
        g_resolver_set_default(gResolver);
    }
    
    /**
     * Synchronously resolves hostname to determine its associated IP
     * address(es). hostname may be an ASCII-only or UTF-8 hostname, or
     * the textual form of an IP address (in which case this just becomes
     * a wrapper around g_inet_address_new_from_string()).
     * On success, g_resolver_lookup_by_name() will return a GList of
     * GInetAddress, sorted in order of preference. (That is, you should
     * attempt to connect to the first address first, then the second if
     * the first fails, etc.)
     * If the DNS resolution fails, error (if non-NULL) will be set to a
     * value from GResolverError.
     * If cancellable is non-NULL, it can be used to cancel the
     * operation, in which case error (if non-NULL) will be set to
     * G_IO_ERROR_CANCELLED.
     * If you are planning to connect to a socket on the resolved IP
     * address, it may be easier to create a GNetworkAddress and use its
     * GSocketConnectable interface.
     * Since 2.22
     * Params:
     * hostname = the hostname to look up
     * cancellable = a GCancellable, or NULL. [allow-none]
     * Returns: a GList of GInetAddress, or NULL on error. You must unref each of the addresses and free the list when you are done with it. (You can use g_resolver_free_addresses() to do this.). [element-type GInetAddress][transfer full]
     * Throws: GException on failure.
     */
    public ListG lookupByName(string hostname, Cancellable cancellable)
    {
        // GList * g_resolver_lookup_by_name (GResolver *resolver,  const gchar *hostname,  GCancellable *cancellable,  GError **error);
        GError* err = null;
        
        auto p = g_resolver_lookup_by_name(gResolver, Str.toStringz(hostname), (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 ListG(cast(GList*) p);
    }
    
    /**
     * Begins asynchronously resolving hostname to determine its
     * associated IP address(es), and eventually calls callback, which
     * must call g_resolver_lookup_by_name_finish() to get the result.
     * See g_resolver_lookup_by_name() for more details.
     * Since 2.22
     * Params:
     * hostname = the hostname to look up the address of
     * cancellable = a GCancellable, or NULL. [allow-none]
     * callback = callback to call after resolution completes. [scope async]
     * userData = data for callback. [closure]
     */
    public void lookupByNameAsync(string hostname, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
    {
        // void g_resolver_lookup_by_name_async (GResolver *resolver,  const gchar *hostname,  GCancellable *cancellable,  GAsyncReadyCallback callback,  gpointer user_data);
        g_resolver_lookup_by_name_async(gResolver, Str.toStringz(hostname), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
    }
    
    /**
     * Retrieves the result of a call to
     * g_resolver_lookup_by_name_async().
     * If the DNS resolution failed, error (if non-NULL) will be set to
     * a value from GResolverError. If the operation was cancelled,
     * error will be set to G_IO_ERROR_CANCELLED.
     * Since 2.22
     * Params:
     * result = the result passed to your GAsyncReadyCallback
     * Returns: a GList of GInetAddress, or NULL on error. See g_resolver_lookup_by_name() for more details. [element-type GInetAddress][transfer full]
     * Throws: GException on failure.
     */
    public ListG lookupByNameFinish(AsyncResultIF result)
    {
        // GList * g_resolver_lookup_by_name_finish (GResolver *resolver,  GAsyncResult *result,  GError **error);
        GError* err = null;
        
        auto p = g_resolver_lookup_by_name_finish(gResolver, (result is null) ? null : result.getAsyncResultTStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        if(p is null)
        {
            return null;
        }
        return new ListG(cast(GList*) p);
    }
    
    /**
     * Frees addresses (which should be the return value from
     * g_resolver_lookup_by_name() or g_resolver_lookup_by_name_finish()).
     * (This is a convenience method; you can also simply free the results
     * by hand.)
     * Since 2.22
     * Params:
     * addresses = a GList of GInetAddress
     */
    public static void freeAddresses(ListG addresses)
    {
        // void g_resolver_free_addresses (GList *addresses);
        g_resolver_free_addresses((addresses is null) ? null : addresses.getListGStruct());
    }
    
    /**
     * Synchronously reverse-resolves address to determine its
     * associated hostname.
     * If the DNS resolution fails, error (if non-NULL) will be set to
     * a value from GResolverError.
     * If cancellable is non-NULL, it can be used to cancel the
     * operation, in which case error (if non-NULL) will be set to
     * G_IO_ERROR_CANCELLED.
     * Since 2.22
     * Params:
     * address = the address to reverse-resolve
     * cancellable = a GCancellable, or NULL. [allow-none]
     * Returns: a hostname (either ASCII-only, or in ASCII-encoded form), or NULL on error.
     * Throws: GException on failure.
     */
    public string lookupByAddress(GInetAddress* address, Cancellable cancellable)
    {
        // gchar * g_resolver_lookup_by_address (GResolver *resolver,  GInetAddress *address,  GCancellable *cancellable,  GError **error);
        GError* err = null;
        
        auto p = g_resolver_lookup_by_address(gResolver, address, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        return Str.toString(p);
    }
    
    /**
     * Begins asynchronously reverse-resolving address to determine its
     * associated hostname, and eventually calls callback, which must
     * call g_resolver_lookup_by_address_finish() to get the final result.
     * Since 2.22
     * Params:
     * address = the address to reverse-resolve
     * cancellable = a GCancellable, or NULL. [allow-none]
     * callback = callback to call after resolution completes. [scope async]
     * userData = data for callback. [closure]
     */
    public void lookupByAddressAsync(GInetAddress* address, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
    {
        // void g_resolver_lookup_by_address_async (GResolver *resolver,  GInetAddress *address,  GCancellable *cancellable,  GAsyncReadyCallback callback,  gpointer user_data);
        g_resolver_lookup_by_address_async(gResolver, address, (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
    }
    
    /**
     * Retrieves the result of a previous call to
     * g_resolver_lookup_by_address_async().
     * If the DNS resolution failed, error (if non-NULL) will be set to
     * a value from GResolverError. If the operation was cancelled,
     * error will be set to G_IO_ERROR_CANCELLED.
     * Since 2.22
     * Params:
     * result = the result passed to your GAsyncReadyCallback
     * Returns: a hostname (either ASCII-only, or in ASCII-encoded form), or NULL on error.
     * Throws: GException on failure.
     */
    public string lookupByAddressFinish(AsyncResultIF result)
    {
        // gchar * g_resolver_lookup_by_address_finish (GResolver *resolver,  GAsyncResult *result,  GError **error);
        GError* err = null;
        
        auto p = g_resolver_lookup_by_address_finish(gResolver, (result is null) ? null : result.getAsyncResultTStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        return Str.toString(p);
    }
    
    /**
     * Synchronously performs a DNS SRV lookup for the given service and
     * protocol in the given domain and returns an array of GSrvTarget.
     * domain may be an ASCII-only or UTF-8 hostname. Note also that the
     * service and protocol arguments do not
     * include the leading underscore that appears in the actual DNS
     * entry.
     * On success, g_resolver_lookup_service() will return a GList of
     * GSrvTarget, sorted in order of preference. (That is, you should
     * attempt to connect to the first target first, then the second if
     * the first fails, etc.)
     * If the DNS resolution fails, error (if non-NULL) will be set to
     * a value from GResolverError.
     * If cancellable is non-NULL, it can be used to cancel the
     * operation, in which case error (if non-NULL) will be set to
     * G_IO_ERROR_CANCELLED.
     * If you are planning to connect to the service, it is usually easier
     * to create a GNetworkService and use its GSocketConnectable
     * interface.
     * Since 2.22
     * Params:
     * service = the service type to look up (eg, "ldap")
     * protocol = the networking protocol to use for service (eg, "tcp")
     * domain = the DNS domain to look up the service in
     * cancellable = a GCancellable, or NULL. [allow-none]
     * Returns: a GList of GSrvTarget, or NULL on error. You must free each of the targets and the list when you are done with it. (You can use g_resolver_free_targets() to do this.). [element-type GSrvTarget][transfer full]
     * Throws: GException on failure.
     */
    public ListG lookupService(string service, string protocol, string domain, Cancellable cancellable)
    {
        // GList * g_resolver_lookup_service (GResolver *resolver,  const gchar *service,  const gchar *protocol,  const gchar *domain,  GCancellable *cancellable,  GError **error);
        GError* err = null;
        
        auto p = g_resolver_lookup_service(gResolver, Str.toStringz(service), Str.toStringz(protocol), Str.toStringz(domain), (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 ListG(cast(GList*) p);
    }
    
    /**
     * Begins asynchronously performing a DNS SRV lookup for the given
     * service and protocol in the given domain, and eventually calls
     * callback, which must call g_resolver_lookup_service_finish() to
     * get the final result. See g_resolver_lookup_service() for more
     * details.
     * Since 2.22
     * Params:
     * service = the service type to look up (eg, "ldap")
     * protocol = the networking protocol to use for service (eg, "tcp")
     * domain = the DNS domain to look up the service in
     * cancellable = a GCancellable, or NULL. [allow-none]
     * callback = callback to call after resolution completes. [scope async]
     * userData = data for callback. [closure]
     */
    public void lookupServiceAsync(string service, string protocol, string domain, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
    {
        // void g_resolver_lookup_service_async (GResolver *resolver,  const gchar *service,  const gchar *protocol,  const gchar *domain,  GCancellable *cancellable,  GAsyncReadyCallback callback,  gpointer user_data);
        g_resolver_lookup_service_async(gResolver, Str.toStringz(service), Str.toStringz(protocol), Str.toStringz(domain), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
    }
    
    /**
     * Retrieves the result of a previous call to
     * g_resolver_lookup_service_async().
     * If the DNS resolution failed, error (if non-NULL) will be set to
     * a value from GResolverError. If the operation was cancelled,
     * error will be set to G_IO_ERROR_CANCELLED.
     * Since 2.22
     * Params:
     * result = the result passed to your GAsyncReadyCallback
     * Returns: a GList of GSrvTarget, or NULL on error. See g_resolver_lookup_service() for more details. [element-type GSrvTarget][transfer full]
     * Throws: GException on failure.
     */
    public ListG lookupServiceFinish(AsyncResultIF result)
    {
        // GList * g_resolver_lookup_service_finish (GResolver *resolver,  GAsyncResult *result,  GError **error);
        GError* err = null;
        
        auto p = g_resolver_lookup_service_finish(gResolver, (result is null) ? null : result.getAsyncResultTStruct(), &err);
        
        if (err !is null)
        {
            throw new GException( new ErrorG(err) );
        }
        
        if(p is null)
        {
            return null;
        }
        return new ListG(cast(GList*) p);
    }
    
    /**
     * Frees targets (which should be the return value from
     * g_resolver_lookup_service() or g_resolver_lookup_service_finish()).
     * (This is a convenience method; you can also simply free the
     * results by hand.)
     * Since 2.22
     * Params:
     * targets = a GList of GSrvTarget
     */
    public static void freeTargets(ListG targets)
    {
        // void g_resolver_free_targets (GList *targets);
        g_resolver_free_targets((targets is null) ? null : targets.getListGStruct());
    }
}