             fatalError("Not implemented")
         }
         
-        set {
-            
-            
-        }
+        set { append(newValue) }
     }
     
     /// Checks whether a message contains Unix file descriptors.


private let DBUS_TYPE_INVALID: CInt = {
    
    let bytes = DBUS_TYPE_INVALID_AS_STRING.utf8.map {$0 as UInt8}
    
    return CInt(bytes[0] + bytes[1])
}()

        
        dbus_message_iter_init_append(internalPointer, &iterator)
        
        for argument in arguments {
            
            switch argument {
                
            case var .Byte(value):
                
                guard dbus_message_iter_append_basic(&iterator, DBusType.Byte.integerValue, &value)
                    else { fatalError("Out of memory! could not append \(argument)") }
                
            case let .Boolean(boolean):
                
                var value = dbus_bool_t(boolean)
                
                guard dbus_message_iter_append_basic(&iterator, DBusType.Boolean.integerValue, &value)
                    else { fatalError("Out of memory! could not append \(argument)") }
                
            case var .Int16(value):
                
                guard dbus_message_iter_append_basic(&iterator, DBusType.Int16.integerValue, &value)
                    else { fatalError("Out of memory! could not append \(argument)") }
                
            case var .UInt16(value):
                
                guard dbus_message_iter_append_basic(&iterator, DBusType.UInt16.integerValue, &value)
                    else { fatalError("Out of memory! could not append \(argument)") }
                
            case var .Int32(value):
                
                guard dbus_message_iter_append_basic(&iterator, DBusType.Int32.integerValue, &value)
                    else { fatalError("Out of memory! could not append \(argument)") }
                
            case var .UInt32(value):
                
                guard dbus_message_iter_append_basic(&iterator, DBusType.UInt32.integerValue, &value)
                    else { fatalError("Out of memory! could not append \(argument)") }
                
            case var .Int64(value):
                
                guard dbus_message_iter_append_basic(&iterator, DBusType.Int64.integerValue, &value)
                    else { fatalError("Out of memory! could not append \(argument)") }
                
            case var .UInt64(value):
                
                guard dbus_message_iter_append_basic(&iterator, DBusType.UInt64.integerValue, &value)
                    else { fatalError("Out of memory! could not append \(argument)") }
                
            case var .Double(value):
                
                guard dbus_message_iter_append_basic(&iterator, DBusType.Double.integerValue, &value)
                    else { fatalError("Out of memory! could not append \(argument)") }
                
            case let .String(value):
                
                var string = convertString(value)
                
                defer { cleanConvertedString(string) }
                
                guard dbus_message_iter_append_basic(&iterator, DBusType.String.integerValue, &string.0)
                    else { fatalError("Out of memory! could not append \(argument)") }
                
            default: fatalError("Not implemented appending: \(argument)")
            }
