// Generated by gmmproc 2.52.1 -- DO NOT MODIFY!
#ifndef _GIOMM_DBUSMESSAGE_H
#define _GIOMM_DBUSMESSAGE_H


#include <glibmm/ustring.h>
#include <sigc++/sigc++.h>

/* Copyright (C) 2010 The giomm Development Team
 *
 * This library 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 2.1 of the License, or (at your option) any later version.
 *
 * This library 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 this library.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <glibmm/object.h>
#include <glibmm/variant.h>
#include <glibmm/utility.h>

#ifdef G_OS_UNIX
# include <giomm/unixfdlist.h>
#endif


#ifndef DOXYGEN_SHOULD_SKIP_THIS
using GDBusMessage = struct _GDBusMessage;
using GDBusMessageClass = struct _GDBusMessageClass;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */


#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Gio
{

namespace DBus
{ class Message_Class; } // namespace DBus

} // namespace Gio
#endif //DOXYGEN_SHOULD_SKIP_THIS

namespace Gio
{

namespace DBus
{

/** @addtogroup giommEnums giomm Enums and Flags */

/** 
 *  @var MessageType MESSAGE_TYPE_INVALID
 * Message is of invalid type.
 * 
 *  @var MessageType MESSAGE_TYPE_METHOD_CALL
 * Method call.
 * 
 *  @var MessageType MESSAGE_TYPE_METHOD_RETURN
 * Method reply.
 * 
 *  @var MessageType MESSAGE_TYPE_ERROR
 * Error reply.
 * 
 *  @var MessageType MESSAGE_TYPE_SIGNAL
 * Signal emission.
 * 
 *  @enum MessageType
 * 
 * Message types used in DBusMessage.
 * 
 * @newin{2,26}
 *
 * @ingroup giommEnums
 */
enum MessageType
{
  MESSAGE_TYPE_INVALID,
  MESSAGE_TYPE_METHOD_CALL,
  MESSAGE_TYPE_METHOD_RETURN,
  MESSAGE_TYPE_ERROR,
  MESSAGE_TYPE_SIGNAL
};


/** 
 *  @var MessageFlags MESSAGE_FLAGS_NONE
 * No flags set.
 * 
 *  @var MessageFlags MESSAGE_FLAGS_NO_REPLY_EXPECTED
 * A reply is not expected.
 * 
 *  @var MessageFlags MESSAGE_FLAGS_NO_AUTO_START
 * The bus must not launch an
 * owner for the destination name in response to this message.
 * 
 *  @var MessageFlags MESSAGE_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION
 * If set on a method
 * call, this flag means that the caller is prepared to wait for interactive
 * authorization. @newin{2,46}
 * 
 *  @enum MessageFlags
 * 
 * Message flags used in DBusMessage.
 * 
 * @newin{2,26}
 *
 * @ingroup giommEnums
 * @par Bitwise operators:
 * <tt>%MessageFlags operator|(MessageFlags, MessageFlags)</tt><br>
 * <tt>%MessageFlags operator&(MessageFlags, MessageFlags)</tt><br>
 * <tt>%MessageFlags operator^(MessageFlags, MessageFlags)</tt><br>
 * <tt>%MessageFlags operator~(MessageFlags)</tt><br>
 * <tt>%MessageFlags& operator|=(MessageFlags&, MessageFlags)</tt><br>
 * <tt>%MessageFlags& operator&=(MessageFlags&, MessageFlags)</tt><br>
 * <tt>%MessageFlags& operator^=(MessageFlags&, MessageFlags)</tt><br>
 */
enum MessageFlags
{
  MESSAGE_FLAGS_NONE = 0x0,
  MESSAGE_FLAGS_NO_REPLY_EXPECTED = (1<<0),
  MESSAGE_FLAGS_NO_AUTO_START = (1<<1),
  MESSAGE_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION = (1<<2)
};

/** @ingroup giommEnums */
inline MessageFlags operator|(MessageFlags lhs, MessageFlags rhs)
  { return static_cast<MessageFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }

/** @ingroup giommEnums */
inline MessageFlags operator&(MessageFlags lhs, MessageFlags rhs)
  { return static_cast<MessageFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }

/** @ingroup giommEnums */
inline MessageFlags operator^(MessageFlags lhs, MessageFlags rhs)
  { return static_cast<MessageFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }

/** @ingroup giommEnums */
inline MessageFlags operator~(MessageFlags flags)
  { return static_cast<MessageFlags>(~static_cast<unsigned>(flags)); }

/** @ingroup giommEnums */
inline MessageFlags& operator|=(MessageFlags& lhs, MessageFlags rhs)
  { return (lhs = static_cast<MessageFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }

/** @ingroup giommEnums */
inline MessageFlags& operator&=(MessageFlags& lhs, MessageFlags rhs)
  { return (lhs = static_cast<MessageFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }

/** @ingroup giommEnums */
inline MessageFlags& operator^=(MessageFlags& lhs, MessageFlags rhs)
  { return (lhs = static_cast<MessageFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }


/** 
 *  @var MessageHeaderField MESSAGE_HEADER_FIELD_INVALID
 * Not a valid header field.
 * 
 *  @var MessageHeaderField MESSAGE_HEADER_FIELD_PATH
 * The object path.
 * 
 *  @var MessageHeaderField MESSAGE_HEADER_FIELD_INTERFACE
 * The interface name.
 * 
 *  @var MessageHeaderField MESSAGE_HEADER_FIELD_MEMBER
 * The method or signal name.
 * 
 *  @var MessageHeaderField MESSAGE_HEADER_FIELD_ERROR_NAME
 * The name of the error that occurred.
 * 
 *  @var MessageHeaderField MESSAGE_HEADER_FIELD_REPLY_SERIAL
 * The serial number the message is a reply to.
 * 
 *  @var MessageHeaderField MESSAGE_HEADER_FIELD_DESTINATION
 * The name the message is intended for.
 * 
 *  @var MessageHeaderField MESSAGE_HEADER_FIELD_SENDER
 * Unique name of the sender of the message (filled in by the bus).
 * 
 *  @var MessageHeaderField MESSAGE_HEADER_FIELD_SIGNATURE
 * The signature of the message body.
 * 
 *  @var MessageHeaderField MESSAGE_HEADER_FIELD_NUM_UNIX_FDS
 * The number of UNIX file descriptors that accompany the message.
 * 
 *  @enum MessageHeaderField
 * 
 * Header fields used in DBusMessage.
 * 
 * @newin{2,26}
 *
 * @ingroup giommEnums
 */
enum MessageHeaderField
{
  MESSAGE_HEADER_FIELD_INVALID,
  MESSAGE_HEADER_FIELD_PATH,
  MESSAGE_HEADER_FIELD_INTERFACE,
  MESSAGE_HEADER_FIELD_MEMBER,
  MESSAGE_HEADER_FIELD_ERROR_NAME,
  MESSAGE_HEADER_FIELD_REPLY_SERIAL,
  MESSAGE_HEADER_FIELD_DESTINATION,
  MESSAGE_HEADER_FIELD_SENDER,
  MESSAGE_HEADER_FIELD_SIGNATURE,
  MESSAGE_HEADER_FIELD_NUM_UNIX_FDS
};


/** 
 *  @var CapabilityFlags CAPABILITY_FLAGS_NONE
 * No flags set.
 * 
 *  @var CapabilityFlags CAPABILITY_FLAGS_UNIX_FD_PASSING
 * The connection
 * supports exchanging UNIX file descriptors with the remote peer.
 * 
 *  @enum CapabilityFlags
 * 
 * Capabilities negotiated with the remote peer.
 * 
 * @newin{2,26}
 *
 * @ingroup giommEnums
 * @par Bitwise operators:
 * <tt>%CapabilityFlags operator|(CapabilityFlags, CapabilityFlags)</tt><br>
 * <tt>%CapabilityFlags operator&(CapabilityFlags, CapabilityFlags)</tt><br>
 * <tt>%CapabilityFlags operator^(CapabilityFlags, CapabilityFlags)</tt><br>
 * <tt>%CapabilityFlags operator~(CapabilityFlags)</tt><br>
 * <tt>%CapabilityFlags& operator|=(CapabilityFlags&, CapabilityFlags)</tt><br>
 * <tt>%CapabilityFlags& operator&=(CapabilityFlags&, CapabilityFlags)</tt><br>
 * <tt>%CapabilityFlags& operator^=(CapabilityFlags&, CapabilityFlags)</tt><br>
 */
enum CapabilityFlags
{
  CAPABILITY_FLAGS_NONE = 0x0,
  CAPABILITY_FLAGS_UNIX_FD_PASSING = (1<<0)
};

/** @ingroup giommEnums */
inline CapabilityFlags operator|(CapabilityFlags lhs, CapabilityFlags rhs)
  { return static_cast<CapabilityFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }

/** @ingroup giommEnums */
inline CapabilityFlags operator&(CapabilityFlags lhs, CapabilityFlags rhs)
  { return static_cast<CapabilityFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }

/** @ingroup giommEnums */
inline CapabilityFlags operator^(CapabilityFlags lhs, CapabilityFlags rhs)
  { return static_cast<CapabilityFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }

/** @ingroup giommEnums */
inline CapabilityFlags operator~(CapabilityFlags flags)
  { return static_cast<CapabilityFlags>(~static_cast<unsigned>(flags)); }

/** @ingroup giommEnums */
inline CapabilityFlags& operator|=(CapabilityFlags& lhs, CapabilityFlags rhs)
  { return (lhs = static_cast<CapabilityFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }

/** @ingroup giommEnums */
inline CapabilityFlags& operator&=(CapabilityFlags& lhs, CapabilityFlags rhs)
  { return (lhs = static_cast<CapabilityFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }

/** @ingroup giommEnums */
inline CapabilityFlags& operator^=(CapabilityFlags& lhs, CapabilityFlags rhs)
  { return (lhs = static_cast<CapabilityFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }


/** A type for representing D-Bus messages that can be sent or received on a
 * Connection.
 *
 * @newin{2,28}
 * @ingroup DBus
 */

class Message : public Glib::Object
{
  
#ifndef DOXYGEN_SHOULD_SKIP_THIS

public:
  using CppObjectType = Message;
  using CppClassType = Message_Class;
  using BaseObjectType = GDBusMessage;
  using BaseClassType = GDBusMessageClass;

  // noncopyable
  Message(const Message&) = delete;
  Message& operator=(const Message&) = delete;

private:  friend class Message_Class;
  static CppClassType message_class_;

protected:
  explicit Message(const Glib::ConstructParams& construct_params);
  explicit Message(GDBusMessage* castitem);

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

public:

  Message(Message&& src) noexcept;
  Message& operator=(Message&& src) noexcept;

  ~Message() noexcept override;

  /** Get the GType for this class, for use with the underlying GObject type system.
   */
  static GType get_type()      G_GNUC_CONST;

#ifndef DOXYGEN_SHOULD_SKIP_THIS


  static GType get_base_type() G_GNUC_CONST;
#endif

  ///Provides access to the underlying C GObject.
  GDBusMessage*       gobj()       { return reinterpret_cast<GDBusMessage*>(gobject_); }

  ///Provides access to the underlying C GObject.
  const GDBusMessage* gobj() const { return reinterpret_cast<GDBusMessage*>(gobject_); }

  ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
  GDBusMessage* gobj_copy();

private:


protected:
  Message();
  

public:
  
  /** Creates a new empty DBusMessage.
   * 
   * @newin{2,26}
   * 
   * @return A DBusMessage. Free with Glib::object_unref().
   */

  
  static Glib::RefPtr<Message> create();


  // Note that we can't use _WRAP_CTOR() and _WRAP_CREATE() because the C functions do more than just call g_object_new():
  // See http://bugzilla.gnome.org/show_bug.cgi?id=624977

  // See here about whether the parameters should be ustring or std::string:
  // http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names
  // They are generally UTF-8 that can only contain the ASCII subset,
  // so ustring still seems preferrable to std::string, which generally implies an unknown encoding for us.

  // The parameter name 'interface' can cause compilation errors with MinGW.
  // See https://bugzilla.gnome.org/show_bug.cgi?id=735137
  // The parameter name in glib is 'interface_'.
  
  /** Creates a new DBusMessage for a signal emission.
   * 
   * @newin{2,26}
   * 
   * @param path A valid object path.
   * @param iface A valid D-Bus interface name.
   * @param signal A valid signal name.
   * @return A DBusMessage. Free with Glib::object_unref().
   */
  static Glib::RefPtr<Message> create_signal(const Glib::ustring& path, const Glib::ustring& iface, const Glib::ustring& signal);
  
  /** Creates a new DBusMessage for a method call.
   * 
   * @newin{2,26}
   * 
   * @param name A valid D-Bus name or <tt>nullptr</tt>.
   * @param path A valid object path.
   * @param iface A valid D-Bus interface name or <tt>nullptr</tt>.
   * @param method A valid method name.
   * @return A DBusMessage. Free with Glib::object_unref().
   */
  static Glib::RefPtr<Message> create_method_call(const Glib::ustring& name, const Glib::ustring& path, const Glib::ustring& iface, const Glib::ustring& method);
  
  /** Creates a new DBusMessage that is a reply to @a method_call_message.
   * 
   * @newin{2,26}
   * 
   * @param method_call_message A message of type DBUS_MESSAGE_TYPE_METHOD_CALL to
   * create a reply message to.
   * @return DBusMessage. Free with Glib::object_unref().
   */
  static Glib::RefPtr<Message> create_method_reply(const Glib::RefPtr<Message>& method_call_message);
  
  /** Creates a new DBusMessage that is an error reply to @a method_call_message.
   * 
   * @newin{2,26}
   * 
   * @param method_call_message A message of type DBUS_MESSAGE_TYPE_METHOD_CALL to
   * create a reply message to.
   * @param error_name A valid D-Bus error name.
   * @param error_message The D-Bus error message.
   * @return A DBusMessage. Free with Glib::object_unref().
   */
  static Glib::RefPtr<Message> create_method_error_literal(const Glib::RefPtr<const Message>& method_call_message, const Glib::ustring& error_name, const Glib::ustring& error_message);

  // Ignore variable argument functions.
  

  /** Creates a new DBusMessage from the data stored at @a blob. The byte
   * order that the message was in can be retrieved using
   * g_dbus_message_get_byte_order().
   * 
   * @newin{2,26}
   * 
   * @param blob A blob represent a binary D-Bus message.
   * @param blob_len The length of @a blob.
   * @param capabilities A DBusCapabilityFlags describing what protocol features are supported.
   * @return A new DBusMessage or <tt>nullptr</tt> if @a error is set. Free with
   * Glib::object_unref().
   */
  static Glib::RefPtr<Message> create_from_blob(const guchar* blob, gsize blob_len, CapabilityFlags capabilities =  CAPABILITY_FLAGS_NONE);


  /** Produces a human-readable multi-line description of @a message.
   * 
   * The contents of the description has no ABI guarantees, the contents
   * and formatting is subject to change at any time. Typical output
   * looks something like this:
   * 
   * [C example ellipted]
   * or
   * 
   * [C example ellipted]
   * 
   * @newin{2,26}
   * 
   * @param indent Indentation level.
   * @return A string.
   */
  Glib::ustring print(guint indent);

  
  /** Checks whether @a message is locked. To monitor changes to this
   * value, conncet to the Object::signal_notify() signal to listen for changes
   * on the DBusMessage::property_locked() property.
   * 
   * @newin{2,26}
   * 
   * @return <tt>true</tt> if @a message is locked, <tt>false</tt> otherwise.
   */
  bool get_locked() const;
  
  /** If @a message is locked, does nothing. Otherwise locks the message.
   * 
   * @newin{2,26}
   */
  void lock();
  
  /** Copies @a message. The copy is a deep copy and the returned
   * DBusMessage is completely identical except that it is guaranteed
   * to not be locked.
   * 
   * This operation can fail if e.g. @a message contains file descriptors
   * and the per-process or system-wide open files limit is reached.
   * 
   * @newin{2,26}
   * 
   * @return A new DBusMessage or <tt>nullptr</tt> if @a error is set.
   * Free with Glib::object_unref().
   */
  Glib::RefPtr<Message> copy() const;

  
  /** Gets the type of @a message.
   * 
   * @newin{2,26}
   * 
   * @return A 8-bit unsigned integer (typically a value from the DBusMessageType enumeration).
   */
  MessageType get_message_type() const;
  
  /** Sets @a message to be of @a type.
   * 
   * @newin{2,26}
   * 
   * @param type A 8-bit unsigned integer (typically a value from the DBusMessageType enumeration).
   */
  void set_message_type(MessageType type);

  //gmmproc can't handle the character literals, and this won't be expanded in future,
  //so we just wrap it by hand.
  enum ByteOrder
  {
    BYTE_ORDER_BIG_ENDIAN    = 'B',
    BYTE_ORDER_LITTLE_ENDIAN = 'l'
  };

   
  /** Gets the byte order of @a message.
   * 
   * @return The byte order.
   */
  ByteOrder get_byte_order() const;
  
  /** Sets the byte order of @a message.
   * 
   * @param byte_order The byte order.
   */
  void set_byte_order(ByteOrder byte_order);

  
  /** Gets the serial for @a message.
   * 
   * @newin{2,26}
   * 
   * @return A #guint32.
   */
  guint32 get_serial() const;
  
  /** Sets the serial for @a message.
   * 
   * @newin{2,26}
   * 
   * @param serial A #guint32.
   */
  void set_serial(guint32 serial);

  
  /** Gets the flags for @a message.
   * 
   * @newin{2,26}
   * 
   * @return Flags that are set (typically values from the DBusMessageFlags enumeration bitwise ORed together).
   */
  MessageFlags get_flags() const;
  
  /** Sets the flags to set on @a message.
   * 
   * @newin{2,26}
   * 
   * @param flags Flags for @a message that are set (typically values from the DBusMessageFlags
   * enumeration bitwise ORed together).
   */
  void set_flags(MessageFlags flags);

  /** Gets the body of a message.  The body is returned in @a value.
   * @param value Location in which to store the header.
   */
  void get_body(Glib::VariantBase& value) const;
  

  /** Sets the body @a message. As a side-effect the
   * DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field is set to the
   * type string of @a body (or cleared if @a body is <tt>nullptr</tt>).
   * 
   * If @a body is floating, @a message assumes ownership of @a body.
   * 
   * @newin{2,26}
   * 
   * @param body Either <tt>nullptr</tt> or a Variant that is a tuple.
   */
  void set_body(const Glib::VariantBase& body);

  
#ifdef  G_OS_UNIX

  /** Gets the UNIX file descriptors associated with @a message, if any.
   * 
   * This method is only available on UNIX.
   * 
   * @newin{2,26}
   * 
   * @return A UnixFDList or <tt>nullptr</tt> if no file descriptors are
   * associated. Do not free, this object is owned by @a message.
   */
  Glib::RefPtr<UnixFDList> get_unix_fd_list();
#endif //  G_OS_UNIX

  
#ifdef  G_OS_UNIX

  /** Gets the UNIX file descriptors associated with @a message, if any.
   * 
   * This method is only available on UNIX.
   * 
   * @newin{2,26}
   * 
   * @return A UnixFDList or <tt>nullptr</tt> if no file descriptors are
   * associated. Do not free, this object is owned by @a message.
   */
  Glib::RefPtr<const UnixFDList> get_unix_fd_list() const;
#endif //  G_OS_UNIX

  
#ifdef  G_OS_UNIX

  /** Sets the UNIX file descriptors associated with @a message. As a
   * side-effect the DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header
   * field is set to the number of fds in @a fd_list (or cleared if
   *  @a fd_list is <tt>nullptr</tt>).
   * 
   * This method is only available on UNIX.
   * 
   * @newin{2,26}
   * 
   * @param fd_list A UnixFDList or <tt>nullptr</tt>.
   */
  void set_unix_fd_list(const Glib::RefPtr<UnixFDList>& fd_list);
#endif //  G_OS_UNIX


#ifdef G_OS_UNIX
  /** Clears the existing UNIX file descriptor list.
   */
  void unset_unix_fd_list();
#endif //G_OS_UNIX

  
  /** Convenience getter for the DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
   * 
   * @newin{2,26}
   * 
   * @return The value.
   */
  guint32 get_num_unix_fds() const;
  
  /** Convenience setter for the DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
   * 
   * @newin{2,26}
   * 
   * @param value The value to set.
   */
  void set_num_unix_fds(guint32 value);

  /** Gets a header field on the message.  The header is returned in @a value.
   * @param value Location in which to store the header.
   * @param header_field The header field type.
   */
  void get_header(Glib::VariantBase& value, MessageHeaderField header_field) const;
  

  /** Sets a header field on @a message.
   * 
   * If @a value is floating, @a message assumes ownership of @a value.
   * 
   * @newin{2,26}
   * 
   * @param header_field A 8-bit unsigned integer (typically a value from the DBusMessageHeaderField enumeration).
   * @param value A Variant to set the header field or <tt>nullptr</tt> to clear the header field.
   */
  void set_header(MessageHeaderField header_field, const Glib::VariantBase& value);

   
  /** Gets an array of all header fields on @a message that are set.
   * 
   * @newin{2,26}
   * 
   * @return An array of header fields
   * terminated by DBUS_MESSAGE_HEADER_FIELD_INVALID.  Each element
   * is a #guchar.
   */
  Glib::ArrayHandle<guchar> get_header_fields() const;

  
  /** Convenience getter for the DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
   * 
   * @newin{2,26}
   * 
   * @return The value.
   */
  Glib::ustring get_destination() const;
  
  /** Convenience setter for the DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
   * 
   * @newin{2,26}
   * 
   * @param value The value to set.
   */
  void set_destination(const Glib::ustring& value);

  
  /** Convenience getter for the DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
   * 
   * @newin{2,26}
   * 
   * @return The value.
   */
  Glib::ustring get_error_name() const;
  
  /** Convenience setter for the DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
   * 
   * @newin{2,26}
   * 
   * @param value The value to set.
   */
  void set_error_name(const Glib::ustring& value);

  
  /** Convenience getter for the DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
   * 
   * @newin{2,26}
   * 
   * @return The value.
   */
  Glib::ustring get_interface() const;
  
  /** Convenience setter for the DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
   * 
   * @newin{2,26}
   * 
   * @param value The value to set.
   */
  void set_interface(const Glib::ustring& value);

  
  /** Convenience getter for the DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
   * 
   * @newin{2,26}
   * 
   * @return The value.
   */
  Glib::ustring get_member() const;
  
  /** Convenience setter for the DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
   * 
   * @newin{2,26}
   * 
   * @param value The value to set.
   */
  void set_member(const Glib::ustring& value);

  
  /** Convenience getter for the DBUS_MESSAGE_HEADER_FIELD_PATH header field.
   * 
   * @newin{2,26}
   * 
   * @return The value.
   */
  Glib::ustring get_path() const;
  
  /** Convenience setter for the DBUS_MESSAGE_HEADER_FIELD_PATH header field.
   * 
   * @newin{2,26}
   * 
   * @param value The value to set.
   */
  void set_path(const Glib::ustring& value);

  
  /** Convenience getter for the DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
   * 
   * @newin{2,26}
   * 
   * @return The value.
   */
  guint32 get_reply_serial() const;
  
  /** Convenience setter for the DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
   * 
   * @newin{2,26}
   * 
   * @param value The value to set.
   */
  void set_reply_serial(guint32 value);

  
  /** Convenience getter for the DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
   * 
   * @newin{2,26}
   * 
   * @return The value.
   */
  Glib::ustring get_sender() const;
  
  /** Convenience setter for the DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
   * 
   * @newin{2,26}
   * 
   * @param value The value to set.
   */
  void set_sender(const Glib::ustring& value);

  
  /** Convenience getter for the DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
   * 
   * @newin{2,26}
   * 
   * @return The value.
   */
  Glib::ustring get_signature() const;
  
  /** Convenience setter for the DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
   * 
   * @newin{2,26}
   * 
   * @param value The value to set.
   */
  void set_signature(const Glib::ustring& value);

  
  /** Convenience to get the first item in the body of @a message.
   * 
   * @newin{2,26}
   * 
   * @return The string item or <tt>nullptr</tt> if the first item in the body of
   *  @a message is not a string.
   */
  Glib::ustring get_arg0() const;

  
  /** Utility function to calculate how many bytes are needed to
   * completely deserialize the D-Bus message stored at @a blob.
   * 
   * @newin{2,26}
   * 
   * @param blob A blob represent a binary D-Bus message.
   * @param blob_len The length of @a blob (must be at least 16).
   * @return Number of bytes needed or -1 if @a error is set (e.g. if
   *  @a blob contains invalid data or not enough data is available to
   * determine the size).
   */
  static gssize bytes_needed(const guchar* blob, gsize blob_len);

  
  /** Serializes @a message to a blob. The byte order returned by
   * g_dbus_message_get_byte_order() will be used.
   * 
   * @newin{2,26}
   * 
   * @param out_size Return location for size of generated blob.
   * @param capabilities A DBusCapabilityFlags describing what protocol features are supported.
   * @return A pointer to a
   * valid binary D-Bus message of @a out_size bytes generated by @a message
   * or <tt>nullptr</tt> if @a error is set.
   */
  guchar* to_blob(gsize& out_size, CapabilityFlags capabilities =  CAPABILITY_FLAGS_NONE);

  
  /** If @a message is not of type DBUS_MESSAGE_TYPE_ERROR does
   * nothing and returns <tt>false</tt>.
   * 
   * Otherwise this method encodes the error in @a message as a Error
   * using g_dbus_error_set_dbus_error() using the information in the
   * DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field of @a message as
   * well as the first string item in @a message's body.
   * 
   * @newin{2,26}
   * 
   * @return <tt>true</tt> if @a error was set, <tt>false</tt> otherwise.
   */
  void to_exception();

  /** Whether the message is locked.
   *
   * @return A PropertyProxy_ReadOnly that allows you to get the value of the property,
   * or receive notification when the value of the property changes.
   */
  Glib::PropertyProxy_ReadOnly< bool > property_locked() const;


public:

public:
  //C++ methods used to invoke GTK+ virtual functions:

protected:
  //GTK+ Virtual Functions (override these to change behaviour):

  //Default Signal Handlers::


};

} //namespace DBus

} // namespace Gio


namespace Glib
{
  /** A Glib::wrap() method for this object.
   *
   * @param object The C instance.
   * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
   * @result A C++ instance that wraps this C instance.
   *
   * @relates Gio::DBus::Message
   */
  Glib::RefPtr<Gio::DBus::Message> wrap(GDBusMessage* object, bool take_copy = false);
}


#endif /* _GIOMM_DBUSMESSAGE_H */

