         dbus_connection_flush(internalPointer)
     }
     
-    /// Registers a handler for a given path in the object hierarchy.
-    ///
-    /// The given `vtable` handles messages sent to exactly the given path.
-    public func registerObjectPath(path: String) throws {
-        
-        let error = DBusErrorInternal()
-        
-        var vtable = DBusObjectPathVTable()
-        
-        vtable.message_function = DBusConnectionPrivateObjectPathMessageFunction
-        
-        
-        
-        guard dbus_connection_try_register_object_path(internalPointer, path, vtable, userData, error.internalPointer).boolValue
-            else { throw error.toError()! }
-    }
-    
-    // MARK: - Properties
+    // MARK: - Dynamic Properties
     
     /// Whether the connection is currently open.
     public var connected: Bool {

import CDBus

/// Type representing a connection to a remote application and associated incoming/outgoing message queues.
public final class DBusConnection {
    
    // MARK: - Properties

        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) }
    }
    
}


