source: appstream-generator/build/girepo/gio/DBusUtilities.d @ 4841

Last change on this file since 4841 was 4841, checked in by Juanma, 2 years ago

Initial release

File size: 11.3 KB
Line 
1/*
2 * Licensed under the GNU Lesser General Public License Version 3
3 *
4 * This library is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU Lesser General Public License as published by
6 * the Free Software Foundation, either version 3 of the license, or
7 * (at your option) any later version.
8 *
9 * This software is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 * GNU Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public License
15 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
16 */
17
18// generated automatically - do not change
19
20
21module gio.DBusUtilities;
22
23private import gi.gio;
24public  import gi.giotypes;
25private import gio.AsyncResultIF;
26private import gio.Cancellable;
27private import gio.IOStream;
28private import glib.ErrorG;
29private import glib.GException;
30private import glib.Str;
31private import glib.Variant;
32private import glib.VariantType;
33private import gobject.ObjectG;
34private import gobject.Value;
35
36
37/** */
38public struct DBusUtilities
39{
40
41        /**
42         * Escape @string so it can appear in a D-Bus address as the value
43         * part of a key-value pair.
44         *
45         * For instance, if @string is "/run/bus-for-:0",
46         * this function would return "/run/bus-for-%3A0",
47         * which could be used in a D-Bus address like
48         * "unix:nonce-tcp:host=127.0.0.1,port=42,noncefile=/run/bus-for-%3A0".
49         *
50         * Params:
51         *     str = an unescaped string to be included in a D-Bus address
52         *         as the value in a key-value pair
53         *
54         * Returns: a copy of @string with all
55         *     non-optionally-escaped bytes escaped
56         *
57         * Since: 2.36
58         */
59        public static string addressEscapeValue(string str)
60        {
61                auto retStr = g_dbus_address_escape_value(Str.toStringz(str));
62               
63                scope(exit) Str.freeString(retStr);
64                return Str.toString(retStr);
65        }
66
67        /**
68         * Synchronously looks up the D-Bus address for the well-known message
69         * bus instance specified by @bus_type. This may involve using various
70         * platform specific mechanisms.
71         *
72         * Params:
73         *     busType = a #GBusType
74         *     cancellable = a #GCancellable or %NULL
75         *
76         * Returns: a valid D-Bus address string for @bus_type or %NULL if
77         *     @error is set
78         *
79         * Since: 2.26
80         *
81         * Throws: GException on failure.
82         */
83        public static string addressGetForBusSync(GBusType busType, Cancellable cancellable)
84        {
85                GError* err = null;
86               
87                auto retStr = g_dbus_address_get_for_bus_sync(busType, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
88               
89                if (err !is null)
90                {
91                        throw new GException( new ErrorG(err) );
92                }
93               
94                scope(exit) Str.freeString(retStr);
95                return Str.toString(retStr);
96        }
97
98        /**
99         * Asynchronously connects to an endpoint specified by @address and
100         * sets up the connection so it is in a state to run the client-side
101         * of the D-Bus authentication conversation.
102         *
103         * When the operation is finished, @callback will be invoked. You can
104         * then call g_dbus_address_get_stream_finish() to get the result of
105         * the operation.
106         *
107         * This is an asynchronous failable function. See
108         * g_dbus_address_get_stream_sync() for the synchronous version.
109         *
110         * Params:
111         *     address = A valid D-Bus address.
112         *     cancellable = A #GCancellable or %NULL.
113         *     callback = A #GAsyncReadyCallback to call when the request is satisfied.
114         *     userData = Data to pass to @callback.
115         *
116         * Since: 2.26
117         */
118        public static void addressGetStream(string address, Cancellable cancellable, GAsyncReadyCallback callback, void* userData)
119        {
120                g_dbus_address_get_stream(Str.toStringz(address), (cancellable is null) ? null : cancellable.getCancellableStruct(), callback, userData);
121        }
122
123        /**
124         * Finishes an operation started with g_dbus_address_get_stream().
125         *
126         * Params:
127         *     res = A #GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_address_get_stream().
128         *     outGuid = %NULL or return location to store the GUID extracted from @address, if any.
129         *
130         * Returns: A #GIOStream or %NULL if @error is set.
131         *
132         * Since: 2.26
133         *
134         * Throws: GException on failure.
135         */
136        public static IOStream addressGetStreamFinish(AsyncResultIF res, out string outGuid)
137        {
138                char* outoutGuid = null;
139                GError* err = null;
140               
141                auto p = g_dbus_address_get_stream_finish((res is null) ? null : res.getAsyncResultStruct(), &outoutGuid, &err);
142               
143                if (err !is null)
144                {
145                        throw new GException( new ErrorG(err) );
146                }
147               
148                outGuid = Str.toString(outoutGuid);
149               
150                if(p is null)
151                {
152                        return null;
153                }
154               
155                return ObjectG.getDObject!(IOStream)(cast(GIOStream*) p, true);
156        }
157
158        /**
159         * Synchronously connects to an endpoint specified by @address and
160         * sets up the connection so it is in a state to run the client-side
161         * of the D-Bus authentication conversation.
162         *
163         * This is a synchronous failable function. See
164         * g_dbus_address_get_stream() for the asynchronous version.
165         *
166         * Params:
167         *     address = A valid D-Bus address.
168         *     outGuid = %NULL or return location to store the GUID extracted from @address, if any.
169         *     cancellable = A #GCancellable or %NULL.
170         *
171         * Returns: A #GIOStream or %NULL if @error is set.
172         *
173         * Since: 2.26
174         *
175         * Throws: GException on failure.
176         */
177        public static IOStream addressGetStreamSync(string address, out string outGuid, Cancellable cancellable)
178        {
179                char* outoutGuid = null;
180                GError* err = null;
181               
182                auto p = g_dbus_address_get_stream_sync(Str.toStringz(address), &outoutGuid, (cancellable is null) ? null : cancellable.getCancellableStruct(), &err);
183               
184                if (err !is null)
185                {
186                        throw new GException( new ErrorG(err) );
187                }
188               
189                outGuid = Str.toString(outoutGuid);
190               
191                if(p is null)
192                {
193                        return null;
194                }
195               
196                return ObjectG.getDObject!(IOStream)(cast(GIOStream*) p, true);
197        }
198
199        /**
200         * Generate a D-Bus GUID that can be used with
201         * e.g. g_dbus_connection_new().
202         *
203         * See the D-Bus specification regarding what strings are valid D-Bus
204         * GUID (for example, D-Bus GUIDs are not RFC-4122 compliant).
205         *
206         * Returns: A valid D-Bus GUID. Free with g_free().
207         *
208         * Since: 2.26
209         */
210        public static string generateGuid()
211        {
212                auto retStr = g_dbus_generate_guid();
213               
214                scope(exit) Str.freeString(retStr);
215                return Str.toString(retStr);
216        }
217
218        /**
219         * Converts a #GValue to a #GVariant of the type indicated by the @type
220         * parameter.
221         *
222         * The conversion is using the following rules:
223         *
224         * - #G_TYPE_STRING: 's', 'o', 'g' or 'ay'
225         * - #G_TYPE_STRV: 'as', 'ao' or 'aay'
226         * - #G_TYPE_BOOLEAN: 'b'
227         * - #G_TYPE_UCHAR: 'y'
228         * - #G_TYPE_INT: 'i', 'n'
229         * - #G_TYPE_UINT: 'u', 'q'
230         * - #G_TYPE_INT64 'x'
231         * - #G_TYPE_UINT64: 't'
232         * - #G_TYPE_DOUBLE: 'd'
233         * - #G_TYPE_VARIANT: Any #GVariantType
234         *
235         * This can fail if e.g. @gvalue is of type #G_TYPE_STRING and @type
236         * is ['i'][G-VARIANT-TYPE-INT32:CAPS]. It will also fail for any #GType
237         * (including e.g. #G_TYPE_OBJECT and #G_TYPE_BOXED derived-types) not
238         * in the table above.
239         *
240         * Note that if @gvalue is of type #G_TYPE_VARIANT and its value is
241         * %NULL, the empty #GVariant instance (never %NULL) for @type is
242         * returned (e.g. 0 for scalar types, the empty string for string types,
243         * '/' for object path types, the empty array for any array type and so on).
244         *
245         * See the g_dbus_gvariant_to_gvalue() function for how to convert a
246         * #GVariant to a #GValue.
247         *
248         * Params:
249         *     gvalue = A #GValue to convert to a #GVariant
250         *     type = A #GVariantType
251         *
252         * Returns: A #GVariant (never floating) of #GVariantType @type holding
253         *     the data from @gvalue or %NULL in case of failure. Free with
254         *     g_variant_unref().
255         *
256         * Since: 2.30
257         */
258        public static Variant gvalueToGvariant(Value gvalue, VariantType type)
259        {
260                auto p = g_dbus_gvalue_to_gvariant((gvalue is null) ? null : gvalue.getValueStruct(), (type is null) ? null : type.getVariantTypeStruct());
261               
262                if(p is null)
263                {
264                        return null;
265                }
266               
267                return new Variant(cast(GVariant*) p, true);
268        }
269
270        /**
271         * Converts a #GVariant to a #GValue. If @value is floating, it is consumed.
272         *
273         * The rules specified in the g_dbus_gvalue_to_gvariant() function are
274         * used - this function is essentially its reverse form.
275         *
276         * The conversion never fails - a valid #GValue is always returned in
277         * @out_gvalue.
278         *
279         * Params:
280         *     value = A #GVariant.
281         *     outGvalue = Return location pointing to a zero-filled (uninitialized) #GValue.
282         *
283         * Since: 2.30
284         */
285        public static void gvariantToGvalue(Variant value, out Value outGvalue)
286        {
287                GValue* outoutGvalue = gMalloc!GValue();
288               
289                g_dbus_gvariant_to_gvalue((value is null) ? null : value.getVariantStruct(), outoutGvalue);
290               
291                outGvalue = ObjectG.getDObject!(Value)(outoutGvalue, true);
292        }
293
294        /**
295         * Checks if @string is a D-Bus address.
296         *
297         * This doesn't check if @string is actually supported by #GDBusServer
298         * or #GDBusConnection - use g_dbus_is_supported_address() to do more
299         * checks.
300         *
301         * Params:
302         *     str = A string.
303         *
304         * Returns: %TRUE if @string is a valid D-Bus address, %FALSE otherwise.
305         *
306         * Since: 2.26
307         */
308        public static bool isAddress(string str)
309        {
310                return g_dbus_is_address(Str.toStringz(str)) != 0;
311        }
312
313        /**
314         * Checks if @string is a D-Bus GUID.
315         *
316         * See the D-Bus specification regarding what strings are valid D-Bus
317         * GUID (for example, D-Bus GUIDs are not RFC-4122 compliant).
318         *
319         * Params:
320         *     str = The string to check.
321         *
322         * Returns: %TRUE if @string is a guid, %FALSE otherwise.
323         *
324         * Since: 2.26
325         */
326        public static bool isGuid(string str)
327        {
328                return g_dbus_is_guid(Str.toStringz(str)) != 0;
329        }
330
331        /**
332         * Checks if @string is a valid D-Bus interface name.
333         *
334         * Params:
335         *     str = The string to check.
336         *
337         * Returns: %TRUE if valid, %FALSE otherwise.
338         *
339         * Since: 2.26
340         */
341        public static bool isInterfaceName(string str)
342        {
343                return g_dbus_is_interface_name(Str.toStringz(str)) != 0;
344        }
345
346        /**
347         * Checks if @string is a valid D-Bus member (e.g. signal or method) name.
348         *
349         * Params:
350         *     str = The string to check.
351         *
352         * Returns: %TRUE if valid, %FALSE otherwise.
353         *
354         * Since: 2.26
355         */
356        public static bool isMemberName(string str)
357        {
358                return g_dbus_is_member_name(Str.toStringz(str)) != 0;
359        }
360
361        /**
362         * Checks if @string is a valid D-Bus bus name (either unique or well-known).
363         *
364         * Params:
365         *     str = The string to check.
366         *
367         * Returns: %TRUE if valid, %FALSE otherwise.
368         *
369         * Since: 2.26
370         */
371        public static bool isName(string str)
372        {
373                return g_dbus_is_name(Str.toStringz(str)) != 0;
374        }
375
376        /**
377         * Like g_dbus_is_address() but also checks if the library suppors the
378         * transports in @string and that key/value pairs for each transport
379         * are valid.
380         *
381         * Params:
382         *     str = A string.
383         *
384         * Returns: %TRUE if @string is a valid D-Bus address that is
385         *     supported by this library, %FALSE if @error is set.
386         *
387         * Since: 2.26
388         *
389         * Throws: GException on failure.
390         */
391        public static bool isSupportedAddress(string str)
392        {
393                GError* err = null;
394               
395                auto p = g_dbus_is_supported_address(Str.toStringz(str), &err) != 0;
396               
397                if (err !is null)
398                {
399                        throw new GException( new ErrorG(err) );
400                }
401               
402                return p;
403        }
404
405        /**
406         * Checks if @string is a valid D-Bus unique bus name.
407         *
408         * Params:
409         *     str = The string to check.
410         *
411         * Returns: %TRUE if valid, %FALSE otherwise.
412         *
413         * Since: 2.26
414         */
415        public static bool isUniqueName(string str)
416        {
417                return g_dbus_is_unique_name(Str.toStringz(str)) != 0;
418        }
419}
Note: See TracBrowser for help on using the repository browser.