     public var anonymous: Bool {
         
         return dbus_connection_get_is_anonymous(internalPointer).boolValue
+    }
+    
+    /// Checks whether there are messages in the outgoing message queue.
+    ///
+    /// Use `DBusConnection.flush()` to block until all outgoing messages have been written to the underlying transport
+    /// (such as a socket).
+    public var hasMessages: Bool {
+        
+        return dbus_connection_has_messages_to_send(internalPointer).boolValue
     }
     
     /// Gets the ID of the server address we are authenticated to, if this connection is on the client side, 

            else { throw error.toError()! }
    }
    
    // MARK: - Methods
    
    /// As long as the connection is open, this function will block until it can read or write, 

        return stringValue
    }
    
    /// Specifies the maximum size message this connection is allowed to receive.
    ///
    /// Larger messages will result in disconnecting the connection.
    public var maximumSize: Int {
        
        get { return dbus_connection_get_max_message_size(internalPointer) }
        
        set { dbus_connection_set_max_message_size(internalPointer, newValue) }
    }
    
    /// Specifies the maximum number of file descriptors a message on this connection is allowed to receive.
    ///
    /// Messages with more file descriptors will result in disconnecting the connection.
    public var maximumFileDescriptors: Int {
        
        get { return dbus_connection_get_max_message_unix_fds(internalPointer) }
        
        set { dbus_connection_set_max_message_unix_fds(internalPointer, newValue) }
    }
    
    /// Sets the maximum total number of bytes that can be used for all messages received on this connection.
    ///
    /// Messages count toward the maximum until they are finalized. 
    /// When the maximum is reached, the connection will not read more data until some messages are finalized.
    ///
    /// The semantics of the maximum are: if outstanding messages are already above the maximum, 
    /// additional messages will not be read.
    /// The semantics are not: if the next message would cause us to exceed the maximum, we don't read it. 
    /// The reason is that we don't know the size of a message until after we read it.
    ///
    /// Thus, the max live messages size can actually be exceeded by up to the maximum size of a single message.
    public var maximumRecievedSize: Int {
        
        get { return dbus_connection_get_max_received_size(internalPointer) }
        
        set { dbus_connection_set_max_received_size(internalPointer, newValue) }
    }
    
    /// Sets the maximum total number of unix fds that can be used for all messages received on this connection.
    ///
    /// Messages count toward the maximum until they are finalized. 
    /// When the maximum is reached, the connection will not read more data until some messages are finalized.
    ///
    /// The semantics are analogous to those of `maximumRecievedSize`.
    public var maximumRecievedFileDescriptors: Int {
        
        get { return dbus_connection_get_max_received_unix_fds(internalPointer) }
        
        set { dbus_connection_set_max_received_unix_fds(internalPointer, newValue) }
    }
    
}


