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