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

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

Initial release

File size: 20.9 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.DBusMessage;
22
23private import gi.gio;
24public  import gi.giotypes;
25private import gio.UnixFDList;
26private import glib.ConstructionException;
27private import glib.ErrorG;
28private import glib.GException;
29private import glib.Str;
30private import glib.Variant;
31private import gobject.ObjectG;
32
33
34/**
35 * A type for representing D-Bus messages that can be sent or received
36 * on a #GDBusConnection.
37 *
38 * Since: 2.26
39 */
40public class DBusMessage : ObjectG
41{
42        /** the main Gtk struct */
43        protected GDBusMessage* gDBusMessage;
44
45        /** Get the main Gtk struct */
46        public GDBusMessage* getDBusMessageStruct()
47        {
48                return gDBusMessage;
49        }
50
51        /** the main Gtk struct as a void* */
52        protected override void* getStruct()
53        {
54                return cast(void*)gDBusMessage;
55        }
56
57        protected override void setStruct(GObject* obj)
58        {
59                gDBusMessage = cast(GDBusMessage*)obj;
60                super.setStruct(obj);
61        }
62
63        /**
64         * Sets our main struct and passes it to the parent class.
65         */
66        public this (GDBusMessage* gDBusMessage, bool ownedRef = false)
67        {
68                this.gDBusMessage = gDBusMessage;
69                super(cast(GObject*)gDBusMessage, ownedRef);
70        }
71
72
73        /** */
74        public static GType getType()
75        {
76                return g_dbus_message_get_type();
77        }
78
79        /**
80         * Creates a new empty #GDBusMessage.
81         *
82         * Returns: A #GDBusMessage. Free with g_object_unref().
83         *
84         * Since: 2.26
85         *
86         * Throws: ConstructionException GTK+ fails to create the object.
87         */
88        public this()
89        {
90                auto p = g_dbus_message_new();
91               
92                if(p is null)
93                {
94                        throw new ConstructionException("null returned by new");
95                }
96               
97                this(cast(GDBusMessage*) p, true);
98        }
99
100        /**
101         * Creates a new #GDBusMessage from the data stored at @blob. The byte
102         * order that the message was in can be retrieved using
103         * g_dbus_message_get_byte_order().
104         *
105         * Params:
106         *     blob = A blob represent a binary D-Bus message.
107         *     blobLen = The length of @blob.
108         *     capabilities = A #GDBusCapabilityFlags describing what protocol features are supported.
109         *
110         * Returns: A new #GDBusMessage or %NULL if @error is set. Free with
111         *     g_object_unref().
112         *
113         * Since: 2.26
114         *
115         * Throws: GException on failure.
116         * Throws: ConstructionException GTK+ fails to create the object.
117         */
118        public this(char[] blob, GDBusCapabilityFlags capabilities)
119        {
120                GError* err = null;
121               
122                auto p = g_dbus_message_new_from_blob(blob.ptr, cast(size_t)blob.length, capabilities, &err);
123               
124                if (err !is null)
125                {
126                        throw new GException( new ErrorG(err) );
127                }
128               
129                if(p is null)
130                {
131                        throw new ConstructionException("null returned by new_from_blob");
132                }
133               
134                this(cast(GDBusMessage*) p, true);
135        }
136
137        /**
138         * Creates a new #GDBusMessage for a method call.
139         *
140         * Params:
141         *     name = A valid D-Bus name or %NULL.
142         *     path = A valid object path.
143         *     iface = A valid D-Bus interface name or %NULL.
144         *     method = A valid method name.
145         *
146         * Returns: A #GDBusMessage. Free with g_object_unref().
147         *
148         * Since: 2.26
149         *
150         * Throws: ConstructionException GTK+ fails to create the object.
151         */
152        public this(string name, string path, string iface, string method)
153        {
154                auto p = g_dbus_message_new_method_call(Str.toStringz(name), Str.toStringz(path), Str.toStringz(iface), Str.toStringz(method));
155               
156                if(p is null)
157                {
158                        throw new ConstructionException("null returned by new_method_call");
159                }
160               
161                this(cast(GDBusMessage*) p, true);
162        }
163
164        /**
165         * Creates a new #GDBusMessage for a signal emission.
166         *
167         * Params:
168         *     path = A valid object path.
169         *     iface = A valid D-Bus interface name.
170         *     signal = A valid signal name.
171         *
172         * Returns: A #GDBusMessage. Free with g_object_unref().
173         *
174         * Since: 2.26
175         *
176         * Throws: ConstructionException GTK+ fails to create the object.
177         */
178        public this(string path, string iface, string signal)
179        {
180                auto p = g_dbus_message_new_signal(Str.toStringz(path), Str.toStringz(iface), Str.toStringz(signal));
181               
182                if(p is null)
183                {
184                        throw new ConstructionException("null returned by new_signal");
185                }
186               
187                this(cast(GDBusMessage*) p, true);
188        }
189
190        /**
191         * Utility function to calculate how many bytes are needed to
192         * completely deserialize the D-Bus message stored at @blob.
193         *
194         * Params:
195         *     blob = A blob represent a binary D-Bus message.
196         *     blobLen = The length of @blob (must be at least 16).
197         *
198         * Returns: Number of bytes needed or -1 if @error is set (e.g. if
199         *     @blob contains invalid data or not enough data is available to
200         *     determine the size).
201         *
202         * Since: 2.26
203         *
204         * Throws: GException on failure.
205         */
206        public static ptrdiff_t bytesNeeded(char[] blob)
207        {
208                GError* err = null;
209               
210                auto p = g_dbus_message_bytes_needed(blob.ptr, cast(size_t)blob.length, &err);
211               
212                if (err !is null)
213                {
214                        throw new GException( new ErrorG(err) );
215                }
216               
217                return p;
218        }
219
220        /**
221         * Copies @message. The copy is a deep copy and the returned
222         * #GDBusMessage is completely identical except that it is guaranteed
223         * to not be locked.
224         *
225         * This operation can fail if e.g. @message contains file descriptors
226         * and the per-process or system-wide open files limit is reached.
227         *
228         * Returns: A new #GDBusMessage or %NULL if @error is set.
229         *     Free with g_object_unref().
230         *
231         * Since: 2.26
232         *
233         * Throws: GException on failure.
234         */
235        public DBusMessage copy()
236        {
237                GError* err = null;
238               
239                auto p = g_dbus_message_copy(gDBusMessage, &err);
240               
241                if (err !is null)
242                {
243                        throw new GException( new ErrorG(err) );
244                }
245               
246                if(p is null)
247                {
248                        return null;
249                }
250               
251                return ObjectG.getDObject!(DBusMessage)(cast(GDBusMessage*) p, true);
252        }
253
254        /**
255         * Convenience to get the first item in the body of @message.
256         *
257         * Returns: The string item or %NULL if the first item in the body of
258         *     @message is not a string.
259         *
260         * Since: 2.26
261         */
262        public string getArg0()
263        {
264                return Str.toString(g_dbus_message_get_arg0(gDBusMessage));
265        }
266
267        /**
268         * Gets the body of a message.
269         *
270         * Returns: A #GVariant or %NULL if the body is
271         *     empty. Do not free, it is owned by @message.
272         *
273         * Since: 2.26
274         */
275        public Variant getBody()
276        {
277                auto p = g_dbus_message_get_body(gDBusMessage);
278               
279                if(p is null)
280                {
281                        return null;
282                }
283               
284                return new Variant(cast(GVariant*) p);
285        }
286
287        /**
288         * Gets the byte order of @message.
289         *
290         * Returns: The byte order.
291         */
292        public GDBusMessageByteOrder getByteOrder()
293        {
294                return g_dbus_message_get_byte_order(gDBusMessage);
295        }
296
297        /**
298         * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
299         *
300         * Returns: The value.
301         *
302         * Since: 2.26
303         */
304        public string getDestination()
305        {
306                return Str.toString(g_dbus_message_get_destination(gDBusMessage));
307        }
308
309        /**
310         * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
311         *
312         * Returns: The value.
313         *
314         * Since: 2.26
315         */
316        public string getErrorName()
317        {
318                return Str.toString(g_dbus_message_get_error_name(gDBusMessage));
319        }
320
321        /**
322         * Gets the flags for @message.
323         *
324         * Returns: Flags that are set (typically values from the #GDBusMessageFlags enumeration bitwise ORed together).
325         *
326         * Since: 2.26
327         */
328        public GDBusMessageFlags getFlags()
329        {
330                return g_dbus_message_get_flags(gDBusMessage);
331        }
332
333        /**
334         * Gets a header field on @message.
335         *
336         * Params:
337         *     headerField = A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
338         *
339         * Returns: A #GVariant with the value if the header was found, %NULL
340         *     otherwise. Do not free, it is owned by @message.
341         *
342         * Since: 2.26
343         */
344        public Variant getHeader(GDBusMessageHeaderField headerField)
345        {
346                auto p = g_dbus_message_get_header(gDBusMessage, headerField);
347               
348                if(p is null)
349                {
350                        return null;
351                }
352               
353                return new Variant(cast(GVariant*) p, true);
354        }
355
356        /**
357         * Gets an array of all header fields on @message that are set.
358         *
359         * Returns: An array of header fields
360         *     terminated by %G_DBUS_MESSAGE_HEADER_FIELD_INVALID.  Each element
361         *     is a #guchar. Free with g_free().
362         *
363         * Since: 2.26
364         */
365        public char[] getHeaderFields()
366        {
367                auto p = g_dbus_message_get_header_fields(gDBusMessage);
368               
369                return p[0 .. getArrayLength(p)];
370        }
371
372        /**
373         * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
374         *
375         * Returns: The value.
376         *
377         * Since: 2.26
378         */
379        public string getInterface()
380        {
381                return Str.toString(g_dbus_message_get_interface(gDBusMessage));
382        }
383
384        /**
385         * Checks whether @message is locked. To monitor changes to this
386         * value, conncet to the #GObject::notify signal to listen for changes
387         * on the #GDBusMessage:locked property.
388         *
389         * Returns: %TRUE if @message is locked, %FALSE otherwise.
390         *
391         * Since: 2.26
392         */
393        public bool getLocked()
394        {
395                return g_dbus_message_get_locked(gDBusMessage) != 0;
396        }
397
398        /**
399         * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
400         *
401         * Returns: The value.
402         *
403         * Since: 2.26
404         */
405        public string getMember()
406        {
407                return Str.toString(g_dbus_message_get_member(gDBusMessage));
408        }
409
410        /**
411         * Gets the type of @message.
412         *
413         * Returns: A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
414         *
415         * Since: 2.26
416         */
417        public GDBusMessageType getMessageType()
418        {
419                return g_dbus_message_get_message_type(gDBusMessage);
420        }
421
422        /**
423         * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
424         *
425         * Returns: The value.
426         *
427         * Since: 2.26
428         */
429        public uint getNumUnixFds()
430        {
431                return g_dbus_message_get_num_unix_fds(gDBusMessage);
432        }
433
434        /**
435         * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
436         *
437         * Returns: The value.
438         *
439         * Since: 2.26
440         */
441        public string getPath()
442        {
443                return Str.toString(g_dbus_message_get_path(gDBusMessage));
444        }
445
446        /**
447         * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
448         *
449         * Returns: The value.
450         *
451         * Since: 2.26
452         */
453        public uint getReplySerial()
454        {
455                return g_dbus_message_get_reply_serial(gDBusMessage);
456        }
457
458        /**
459         * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
460         *
461         * Returns: The value.
462         *
463         * Since: 2.26
464         */
465        public string getSender()
466        {
467                return Str.toString(g_dbus_message_get_sender(gDBusMessage));
468        }
469
470        /**
471         * Gets the serial for @message.
472         *
473         * Returns: A #guint32.
474         *
475         * Since: 2.26
476         */
477        public uint getSerial()
478        {
479                return g_dbus_message_get_serial(gDBusMessage);
480        }
481
482        /**
483         * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
484         *
485         * Returns: The value.
486         *
487         * Since: 2.26
488         */
489        public string getSignature()
490        {
491                return Str.toString(g_dbus_message_get_signature(gDBusMessage));
492        }
493
494        /**
495         * Gets the UNIX file descriptors associated with @message, if any.
496         *
497         * This method is only available on UNIX.
498         *
499         * Returns: A #GUnixFDList or %NULL if no file descriptors are
500         *     associated. Do not free, this object is owned by @message.
501         *
502         * Since: 2.26
503         */
504        public UnixFDList getUnixFdList()
505        {
506                auto p = g_dbus_message_get_unix_fd_list(gDBusMessage);
507               
508                if(p is null)
509                {
510                        return null;
511                }
512               
513                return ObjectG.getDObject!(UnixFDList)(cast(GUnixFDList*) p);
514        }
515
516        /**
517         * If @message is locked, does nothing. Otherwise locks the message.
518         *
519         * Since: 2.26
520         */
521        public void lock()
522        {
523                g_dbus_message_lock(gDBusMessage);
524        }
525
526        /**
527         * Creates a new #GDBusMessage that is an error reply to @method_call_message.
528         *
529         * Params:
530         *     errorName = A valid D-Bus error name.
531         *     errorMessage = The D-Bus error message.
532         *
533         * Returns: A #GDBusMessage. Free with g_object_unref().
534         *
535         * Since: 2.26
536         */
537        public DBusMessage newMethodErrorLiteral(string errorName, string errorMessage)
538        {
539                auto p = g_dbus_message_new_method_error_literal(gDBusMessage, Str.toStringz(errorName), Str.toStringz(errorMessage));
540               
541                if(p is null)
542                {
543                        return null;
544                }
545               
546                return ObjectG.getDObject!(DBusMessage)(cast(GDBusMessage*) p, true);
547        }
548
549        /**
550         * Like g_dbus_message_new_method_error() but intended for language bindings.
551         *
552         * Params:
553         *     errorName = A valid D-Bus error name.
554         *     errorMessageFormat = The D-Bus error message in a printf() format.
555         *     varArgs = Arguments for @error_message_format.
556         *
557         * Returns: A #GDBusMessage. Free with g_object_unref().
558         *
559         * Since: 2.26
560         */
561        public DBusMessage newMethodErrorValist(string errorName, string errorMessageFormat, void* varArgs)
562        {
563                auto p = g_dbus_message_new_method_error_valist(gDBusMessage, Str.toStringz(errorName), Str.toStringz(errorMessageFormat), varArgs);
564               
565                if(p is null)
566                {
567                        return null;
568                }
569               
570                return ObjectG.getDObject!(DBusMessage)(cast(GDBusMessage*) p, true);
571        }
572
573        /**
574         * Creates a new #GDBusMessage that is a reply to @method_call_message.
575         *
576         * Returns: #GDBusMessage. Free with g_object_unref().
577         *
578         * Since: 2.26
579         */
580        public DBusMessage newMethodReply()
581        {
582                auto p = g_dbus_message_new_method_reply(gDBusMessage);
583               
584                if(p is null)
585                {
586                        return null;
587                }
588               
589                return ObjectG.getDObject!(DBusMessage)(cast(GDBusMessage*) p, true);
590        }
591
592        /**
593         * Produces a human-readable multi-line description of @message.
594         *
595         * The contents of the description has no ABI guarantees, the contents
596         * and formatting is subject to change at any time. Typical output
597         * looks something like this:
598         * |[
599         * Flags:   none
600         * Version: 0
601         * Serial:  4
602         * Headers:
603         * path -> objectpath '/org/gtk/GDBus/TestObject'
604         * interface -> 'org.gtk.GDBus.TestInterface'
605         * member -> 'GimmeStdout'
606         * destination -> ':1.146'
607         * Body: ()
608         * UNIX File Descriptors:
609         * (none)
610         * ]|
611         * or
612         * |[
613         * Flags:   no-reply-expected
614         * Version: 0
615         * Serial:  477
616         * Headers:
617         * reply-serial -> uint32 4
618         * destination -> ':1.159'
619         * sender -> ':1.146'
620         * num-unix-fds -> uint32 1
621         * Body: ()
622         * UNIX File Descriptors:
623         * fd 12: dev=0:10,mode=020620,ino=5,uid=500,gid=5,rdev=136:2,size=0,atime=1273085037,mtime=1273085851,ctime=1272982635
624         * ]|
625         *
626         * Params:
627         *     indent = Indentation level.
628         *
629         * Returns: A string that should be freed with g_free().
630         *
631         * Since: 2.26
632         */
633        public string print(uint indent)
634        {
635                auto retStr = g_dbus_message_print(gDBusMessage, indent);
636               
637                scope(exit) Str.freeString(retStr);
638                return Str.toString(retStr);
639        }
640
641        /**
642         * Sets the body @message. As a side-effect the
643         * %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field is set to the
644         * type string of @body (or cleared if @body is %NULL).
645         *
646         * If @body is floating, @message assumes ownership of @body.
647         *
648         * Params:
649         *     bod = Either %NULL or a #GVariant that is a tuple.
650         *
651         * Since: 2.26
652         */
653        public void setBody(Variant bod)
654        {
655                g_dbus_message_set_body(gDBusMessage, (bod is null) ? null : bod.getVariantStruct());
656        }
657
658        /**
659         * Sets the byte order of @message.
660         *
661         * Params:
662         *     byteOrder = The byte order.
663         */
664        public void setByteOrder(GDBusMessageByteOrder byteOrder)
665        {
666                g_dbus_message_set_byte_order(gDBusMessage, byteOrder);
667        }
668
669        /**
670         * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
671         *
672         * Params:
673         *     value = The value to set.
674         *
675         * Since: 2.26
676         */
677        public void setDestination(string value)
678        {
679                g_dbus_message_set_destination(gDBusMessage, Str.toStringz(value));
680        }
681
682        /**
683         * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
684         *
685         * Params:
686         *     value = The value to set.
687         *
688         * Since: 2.26
689         */
690        public void setErrorName(string value)
691        {
692                g_dbus_message_set_error_name(gDBusMessage, Str.toStringz(value));
693        }
694
695        /**
696         * Sets the flags to set on @message.
697         *
698         * Params:
699         *     flags = Flags for @message that are set (typically values from the #GDBusMessageFlags
700         *         enumeration bitwise ORed together).
701         *
702         * Since: 2.26
703         */
704        public void setFlags(GDBusMessageFlags flags)
705        {
706                g_dbus_message_set_flags(gDBusMessage, flags);
707        }
708
709        /**
710         * Sets a header field on @message.
711         *
712         * If @value is floating, @message assumes ownership of @value.
713         *
714         * Params:
715         *     headerField = A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
716         *     value = A #GVariant to set the header field or %NULL to clear the header field.
717         *
718         * Since: 2.26
719         */
720        public void setHeader(GDBusMessageHeaderField headerField, Variant value)
721        {
722                g_dbus_message_set_header(gDBusMessage, headerField, (value is null) ? null : value.getVariantStruct());
723        }
724
725        /**
726         * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
727         *
728         * Params:
729         *     value = The value to set.
730         *
731         * Since: 2.26
732         */
733        public void setInterface(string value)
734        {
735                g_dbus_message_set_interface(gDBusMessage, Str.toStringz(value));
736        }
737
738        /**
739         * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
740         *
741         * Params:
742         *     value = The value to set.
743         *
744         * Since: 2.26
745         */
746        public void setMember(string value)
747        {
748                g_dbus_message_set_member(gDBusMessage, Str.toStringz(value));
749        }
750
751        /**
752         * Sets @message to be of @type.
753         *
754         * Params:
755         *     type = A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
756         *
757         * Since: 2.26
758         */
759        public void setMessageType(GDBusMessageType type)
760        {
761                g_dbus_message_set_message_type(gDBusMessage, type);
762        }
763
764        /**
765         * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
766         *
767         * Params:
768         *     value = The value to set.
769         *
770         * Since: 2.26
771         */
772        public void setNumUnixFds(uint value)
773        {
774                g_dbus_message_set_num_unix_fds(gDBusMessage, value);
775        }
776
777        /**
778         * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
779         *
780         * Params:
781         *     value = The value to set.
782         *
783         * Since: 2.26
784         */
785        public void setPath(string value)
786        {
787                g_dbus_message_set_path(gDBusMessage, Str.toStringz(value));
788        }
789
790        /**
791         * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
792         *
793         * Params:
794         *     value = The value to set.
795         *
796         * Since: 2.26
797         */
798        public void setReplySerial(uint value)
799        {
800                g_dbus_message_set_reply_serial(gDBusMessage, value);
801        }
802
803        /**
804         * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
805         *
806         * Params:
807         *     value = The value to set.
808         *
809         * Since: 2.26
810         */
811        public void setSender(string value)
812        {
813                g_dbus_message_set_sender(gDBusMessage, Str.toStringz(value));
814        }
815
816        /**
817         * Sets the serial for @message.
818         *
819         * Params:
820         *     serial = A #guint32.
821         *
822         * Since: 2.26
823         */
824        public void setSerial(uint serial)
825        {
826                g_dbus_message_set_serial(gDBusMessage, serial);
827        }
828
829        /**
830         * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
831         *
832         * Params:
833         *     value = The value to set.
834         *
835         * Since: 2.26
836         */
837        public void setSignature(string value)
838        {
839                g_dbus_message_set_signature(gDBusMessage, Str.toStringz(value));
840        }
841
842        /**
843         * Sets the UNIX file descriptors associated with @message. As a
844         * side-effect the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header
845         * field is set to the number of fds in @fd_list (or cleared if
846         * @fd_list is %NULL).
847         *
848         * This method is only available on UNIX.
849         *
850         * Params:
851         *     fdList = A #GUnixFDList or %NULL.
852         *
853         * Since: 2.26
854         */
855        public void setUnixFdList(UnixFDList fdList)
856        {
857                g_dbus_message_set_unix_fd_list(gDBusMessage, (fdList is null) ? null : fdList.getUnixFDListStruct());
858        }
859
860        /**
861         * Serializes @message to a blob. The byte order returned by
862         * g_dbus_message_get_byte_order() will be used.
863         *
864         * Params:
865         *     capabilities = A #GDBusCapabilityFlags describing what protocol features are supported.
866         *
867         * Returns: A pointer to a
868         *     valid binary D-Bus message of @out_size bytes generated by @message
869         *     or %NULL if @error is set. Free with g_free().
870         *
871         * Since: 2.26
872         *
873         * Throws: GException on failure.
874         */
875        public char[] toBlob(GDBusCapabilityFlags capabilities)
876        {
877                size_t outSize;
878                GError* err = null;
879               
880                auto p = g_dbus_message_to_blob(gDBusMessage, &outSize, capabilities, &err);
881               
882                if (err !is null)
883                {
884                        throw new GException( new ErrorG(err) );
885                }
886               
887                return p[0 .. outSize];
888        }
889
890        /**
891         * If @message is not of type %G_DBUS_MESSAGE_TYPE_ERROR does
892         * nothing and returns %FALSE.
893         *
894         * Otherwise this method encodes the error in @message as a #GError
895         * using g_dbus_error_set_dbus_error() using the information in the
896         * %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field of @message as
897         * well as the first string item in @message's body.
898         *
899         * Returns: %TRUE if @error was set, %FALSE otherwise.
900         *
901         * Since: 2.26
902         *
903         * Throws: GException on failure.
904         */
905        public bool toGerror()
906        {
907                GError* err = null;
908               
909                auto p = g_dbus_message_to_gerror(gDBusMessage, &err) != 0;
910               
911                if (err !is null)
912                {
913                        throw new GException( new ErrorG(err) );
914                }
915               
916                return p;
917        }
918}
Note: See TracBrowser for help on using the repository browser.