no message

Postbox/Coding.swift

@@ -5,7 +5,7 @@ public protocol Coding {
     func encode(encoder: Encoder)
 }
 
-private struct EncodableTypeStore {
+private final class EncodableTypeStore {
     var dict: [Int32 : Decoder -> Coding] = [:]
     
     func decode(typeHash: Int32, decoder: Decoder) -> Coding? {
@@ -17,7 +17,10 @@ private struct EncodableTypeStore {
     }
 }
 
-private var typeStore = EncodableTypeStore()
+private let _typeStore = EncodableTypeStore()
+private let typeStore = { () -> EncodableTypeStore in
+    return _typeStore
+}()
 
 public func declareEncodable(type: Any.Type, f: Decoder -> Coding) {
     let string = "\(type)"
@@ -28,22 +31,62 @@ public func declareEncodable(type: Any.Type, f: Decoder -> Coding) {
     typeStore.dict[murMurHashString32("\(type)")] = f
 }
 
-public final class WriteBuffer {
-    var memory: UnsafeMutablePointer<Void> = nil
+public class MemoryBuffer: Equatable, CustomStringConvertible {
+    var memory: UnsafeMutablePointer<Void>
     var capacity: Int
-    var offset: Int
+    var length: Int
+    var freeWhenDone: Bool
+    
+    public init(memory: UnsafeMutablePointer<Void>, capacity: Int, length: Int, freeWhenDone: Bool) {
+        self.memory = memory
+        self.capacity = capacity
+        self.length = length
+        self.freeWhenDone = freeWhenDone
+    }
+    
+    public init(data: NSData) {
+        self.memory = UnsafeMutablePointer(data.bytes)
+        self.capacity = data.length
+        self.length = data.length
+        self.freeWhenDone = false
+    }
     
     public init() {
-        self.memory = malloc(32)
-        self.capacity = 32
-        self.offset = 0
+        self.memory = nil
+        self.capacity = 0
+        self.length = 0
+        self.freeWhenDone = false
     }
     
     deinit {
-        free(self.memory)
+        if self.freeWhenDone {
+            free(self.memory)
+        }
     }
     
-    func makeReadBufferAndReset() -> ReadBuffer {
+    public var description: String {
+        let hexString = NSMutableString()
+        let bytes = UnsafeMutablePointer<UInt8>(self.memory)
+        for i in 0 ..< self.length {
+            hexString.appendFormat("%02x", UInt(bytes[i]))
+        }
+        
+        return hexString as String
+    }
+}
+
+public func ==(lhs: MemoryBuffer, rhs: MemoryBuffer) -> Bool {
+    return lhs.length == rhs.length && memcmp(lhs.memory, rhs.memory, lhs.length) == 0
+}
+
+public final class WriteBuffer: MemoryBuffer {
+    var offset = 0
+    
+    public override init() {
+        super.init(memory: malloc(32), capacity: 32, length: 0, freeWhenDone: true)
+    }
+    
+    public func makeReadBufferAndReset() -> ReadBuffer {
         let buffer = ReadBuffer(memory: self.memory, length: self.offset, freeWhenDone: true)
         self.memory = malloc(32)
         self.capacity = 32
@@ -51,7 +94,11 @@ public final class WriteBuffer {
         return buffer
     }
     
-    func makeData() -> NSData {
+    public func readBufferNoCopy() -> ReadBuffer {
+        return ReadBuffer(memory: self.memory, length: self.offset, freeWhenDone: false)
+    }
+    
+    public func makeData() -> NSData {
         return NSData(bytes: self.memory, length: self.offset)
     }
     
@@ -59,33 +106,30 @@ public final class WriteBuffer {
         self.offset = 0
     }
     
-    func write(data: UnsafePointer<Void>, offset: Int, length: Int) {
+    public func write(data: UnsafePointer<Void>, offset: Int, length: Int) {
         if self.offset + length > self.capacity {
             self.capacity = self.offset + length + 256
             self.memory = realloc(self.memory, self.capacity)
         }
         memcpy(self.memory + self.offset, data + offset, length)
         self.offset += length
+        self.length = self.offset
     }
 }
 
-public final class ReadBuffer {
-    var memory: UnsafeMutablePointer<Void>
-    var length: Int
-    var offset : Int
-    let freeWhenDone: Bool
+public final class ReadBuffer: MemoryBuffer {
+    var offset = 0
     
-    init(memory: UnsafeMutablePointer<Void>, length: Int, freeWhenDone: Bool) {
-        self.memory = memory
-        self.length = length
-        self.offset = 0
-        self.freeWhenDone = freeWhenDone
+    public init(memory: UnsafeMutablePointer<Void>, length: Int, freeWhenDone: Bool) {
+        super.init(memory: memory, capacity: length, length: length, freeWhenDone: freeWhenDone)
     }
     
-    deinit {
-        if self.freeWhenDone {
-            free(self.memory)
-        }
+    public init(memoryBufferNoCopy: MemoryBuffer) {
+        super.init(memory: memoryBufferNoCopy.memory, capacity: memoryBufferNoCopy.length, length: memoryBufferNoCopy.length, freeWhenDone: false)
+    }
+    
+    func dataNoCopy() -> NSData {
+        return NSData(bytesNoCopy: self.memory, length: self.length, freeWhenDone: false)
     }
     
     func read(data: UnsafeMutablePointer<Void>, offset: Int, length: Int) {
@@ -118,6 +162,10 @@ public final class Encoder {
     public init() {
     }
     
+    public func memoryBuffer() -> MemoryBuffer {
+        return self.buffer
+    }
+    
     public func makeReadBufferAndReset() -> ReadBuffer {
         return self.buffer.makeReadBufferAndReset()
     }
@@ -130,20 +178,13 @@ public final class Encoder {
         self.buffer.reset()
     }
     
-    public func encodeKey(key: UnsafePointer<Int8>) {
-        var length: Int8 = Int8(strlen(key))
+    public func encodeKey(key: StaticString) {
+        var length: Int8 = Int8(key.byteSize)
         self.buffer.write(&length, offset: 0, length: 1)
-        self.buffer.write(UnsafePointer<Void>(key), offset: 0, length: Int(length))
+        self.buffer.write(key.utf8Start, offset: 0, length: Int(length))
     }
     
-    public func encodeKey(key: Int8) {
-        var length: Int8 = 1
-        self.buffer.write(&length, offset: 0, length: 1)
-        var keyValue = key
-        self.buffer.write(&keyValue, offset: 0, length: Int(length))
-    }
-    
-    public func encodeInt32(value: Int32, forKey key: UnsafePointer<Int8>) {
+    public func encodeInt32(value: Int32, forKey key: StaticString) {
         self.encodeKey(key)
         var type: Int8 = ValueType.Int32.rawValue
         self.buffer.write(&type, offset: 0, length: 1)
@@ -151,15 +192,7 @@ public final class Encoder {
         self.buffer.write(&v, offset: 0, length: 4)
     }
     
-    public func encodeInt32(value: Int32, forKey key: Int8) {
-        self.encodeKey(key)
-        var type: Int8 = ValueType.Int32.rawValue
-        self.buffer.write(&type, offset: 0, length: 1)
-        var v = value
-        self.buffer.write(&v, offset: 0, length: 4)
-    }
-    
-    public func encodeInt64(value: Int64, forKey key: UnsafePointer<Int8>) {
+    public func encodeInt64(value: Int64, forKey key: StaticString) {
         self.encodeKey(key)
         var type: Int8 = ValueType.Int64.rawValue
         self.buffer.write(&type, offset: 0, length: 1)
@@ -167,15 +200,7 @@ public final class Encoder {
         self.buffer.write(&v, offset: 0, length: 8)
     }
     
-    public func encodeInt64(value: Int64, forKey key: Int8) {
-        self.encodeKey(key)
-        var type: Int8 = ValueType.Int64.rawValue
-        self.buffer.write(&type, offset: 0, length: 1)
-        var v = value
-        self.buffer.write(&v, offset: 0, length: 8)
-    }
-    
-    public func encodeBool(value: Bool, forKey key: UnsafePointer<Int8>) {
+    public func encodeBool(value: Bool, forKey key: StaticString) {
         self.encodeKey(key)
         var type: Int8 = ValueType.Bool.rawValue
         self.buffer.write(&type, offset: 0, length: 1)
@@ -183,15 +208,7 @@ public final class Encoder {
         self.buffer.write(&v, offset: 0, length: 1)
     }
     
-    public func encodeBool(value: Bool, forKey key: Int8) {
-        self.encodeKey(key)
-        var type: Int8 = ValueType.Bool.rawValue
-        self.buffer.write(&type, offset: 0, length: 1)
-        var v: Int8 = value ? 1 : 0
-        self.buffer.write(&v, offset: 0, length: 1)
-    }
-    
-    public func encodeDouble(value: Double, forKey key: UnsafePointer<Int8>) {
+    public func encodeDouble(value: Double, forKey key: StaticString) {
         self.encodeKey(key)
         var type: Int8 = ValueType.Double.rawValue
         self.buffer.write(&type, offset: 0, length: 1)
@@ -199,15 +216,7 @@ public final class Encoder {
         self.buffer.write(&v, offset: 0, length: 8)
     }
     
-    public func encodeDouble(value: Double, forKey key: Int8) {
-        self.encodeKey(key)
-        var type: Int8 = ValueType.Double.rawValue
-        self.buffer.write(&type, offset: 0, length: 1)
-        var v = value
-        self.buffer.write(&v, offset: 0, length: 8)
-    }
-    
-    public func encodeString(value: String, forKey key: UnsafePointer<Int8>) {
+    public func encodeString(value: String, forKey key: StaticString) {
         self.encodeKey(key)
         var type: Int8 = ValueType.String.rawValue
         self.buffer.write(&type, offset: 0, length: 1)
@@ -217,7 +226,7 @@ public final class Encoder {
         self.buffer.write(data.bytes, offset: 0, length: Int(length))
     }
     
-    public func encodeString(value: DeferredString, forKey key: UnsafePointer<Int8>) {
+    public func encodeString(value: DeferredString, forKey key: StaticString) {
         self.encodeKey(key)
         var type: Int8 = ValueType.String.rawValue
         self.buffer.write(&type, offset: 0, length: 1)
@@ -227,21 +236,11 @@ public final class Encoder {
         self.buffer.write(data.bytes, offset: 0, length: Int(length))
     }
     
-    public func encodeString(value: String, forKey key: Int8) {
-        self.encodeKey(key)
-        var type: Int8 = ValueType.String.rawValue
-        self.buffer.write(&type, offset: 0, length: 1)
-        let data = value.dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: true)!
-        var length: Int32 = Int32(data.length)
-        self.buffer.write(&length, offset: 0, length: 4)
-        self.buffer.write(data.bytes, offset: 0, length: Int(length))
-    }
-    
     public func encodeRootObject(value: Coding) {
         self.encodeObject(value, forKey: "_")
     }
     
-    public func encodeObject(value: Coding, forKey key: UnsafePointer<Int8>) {
+    public func encodeObject(value: Coding, forKey key: StaticString) {
         self.encodeKey(key)
         var type: Int8 = ValueType.Object.rawValue
         self.buffer.write(&type, offset: 0, length: 1)
@@ -258,7 +257,7 @@ public final class Encoder {
         self.buffer.write(innerEncoder.buffer.memory, offset: 0, length: Int(length))
     }
     
-    public func encodeInt32Array(value: [Int32], forKey key: UnsafePointer<Int8>) {
+    public func encodeInt32Array(value: [Int32], forKey key: StaticString) {
         self.encodeKey(key)
         var type: Int8 = ValueType.Int32Array.rawValue
         self.buffer.write(&type, offset: 0, length: 1)
@@ -270,7 +269,7 @@ public final class Encoder {
         }
     }
     
-    public func encodeInt64Array(value: [Int64], forKey key: UnsafePointer<Int8>) {
+    public func encodeInt64Array(value: [Int64], forKey key: StaticString) {
         self.encodeKey(key)
         var type: Int8 = ValueType.Int64Array.rawValue
         self.buffer.write(&type, offset: 0, length: 1)
@@ -282,7 +281,7 @@ public final class Encoder {
         }
     }
     
-    public func encodeObjectArray<T: Coding>(value: [T], forKey key: UnsafePointer<Int8>) {
+    public func encodeObjectArray<T: Coding>(value: [T], forKey key: StaticString) {
         self.encodeKey(key)
         var type: Int8 = ValueType.ObjectArray.rawValue
         self.buffer.write(&type, offset: 0, length: 1)
@@ -302,7 +301,27 @@ public final class Encoder {
         }
     }
     
-    public func encodeObjectDictionary<K, V: Coding where K: Coding, K: Hashable>(value: [K : V], forKey key: UnsafePointer<Int8>) {
+    public func encodeObjectArray(value: [Coding], forKey key: StaticString) {
+        self.encodeKey(key)
+        var type: Int8 = ValueType.ObjectArray.rawValue
+        self.buffer.write(&type, offset: 0, length: 1)
+        var length: Int32 = Int32(value.count)
+        self.buffer.write(&length, offset: 0, length: 4)
+        let innerEncoder = Encoder()
+        for object in value {
+            var typeHash: Int32 = murMurHashString32("\(object.dynamicType)")
+            self.buffer.write(&typeHash, offset: 0, length: 4)
+            
+            innerEncoder.reset()
+            object.encode(innerEncoder)
+            
+            var length: Int32 = Int32(innerEncoder.buffer.offset)
+            self.buffer.write(&length, offset: 0, length: 4)
+            self.buffer.write(innerEncoder.buffer.memory, offset: 0, length: Int(length))
+        }
+    }
+    
+    public func encodeObjectDictionary<K, V: Coding where K: Coding, K: Hashable>(value: [K : V], forKey key: StaticString) {
         self.encodeKey(key)
         var type: Int8 = ValueType.ObjectDictionary.rawValue
         self.buffer.write(&type, offset: 0, length: 1)
@@ -329,7 +348,16 @@ public final class Encoder {
         }
     }
     
-    public func encodeBytes(bytes: WriteBuffer, forKey key: UnsafePointer<Int8>) {
+    public func encodeBytes(bytes: WriteBuffer, forKey key: StaticString) {
+        self.encodeKey(key)
+        var type: Int8 = ValueType.Bytes.rawValue
+        self.buffer.write(&type, offset: 0, length: 1)
+        var bytesLength: Int32 = Int32(bytes.offset)
+        self.buffer.write(&bytesLength, offset: 0, length: 4)
+        self.buffer.write(bytes.memory, offset: 0, length: bytes.offset)
+    }
+    
+    public func encodeBytes(bytes: ReadBuffer, forKey key: StaticString) {
         self.encodeKey(key)
         var type: Int8 = ValueType.Bytes.rawValue
         self.buffer.write(&type, offset: 0, length: 1)
@@ -342,9 +370,10 @@ public final class Encoder {
 }
 
 public final class Decoder {
-    private let buffer: ReadBuffer
+    private let buffer: MemoryBuffer
+    private var offset: Int = 0
     
-    public init(buffer: ReadBuffer) {
+    public init(buffer: MemoryBuffer) {
         self.buffer = buffer
     }
     
@@ -407,11 +436,11 @@ public final class Decoder {
         }
     }
     
-    private class func positionOnKey(bytes: UnsafePointer<Int8>, inout offset: Int, maxOffset: Int, length: Int, key: UnsafePointer<Int8>, valueType: ValueType) -> Bool
+    private class func positionOnKey(bytes: UnsafePointer<Int8>, inout offset: Int, maxOffset: Int, length: Int, key: StaticString, valueType: ValueType) -> Bool
     {
         let startOffset = offset
         
-        let keyLength: Int = Int(strlen(key))
+        let keyLength: Int = key.byteSize
         while (offset < maxOffset)
         {
             let readKeyLength = bytes[offset]
@@ -421,7 +450,7 @@ public final class Decoder {
             let readValueType = bytes[offset]
             offset += 1
             
-            if readValueType != valueType.rawValue || keyLength != Int(readKeyLength) || memcmp(bytes + (offset - Int(readKeyLength) - 1), key, keyLength) != 0 {
+            if readValueType != valueType.rawValue || keyLength != Int(readKeyLength) || memcmp(bytes + (offset - Int(readKeyLength) - 1), key.utf8Start, keyLength) != 0 {
                 skipValue(bytes, offset: &offset, length: length, valueType: ValueType(rawValue: readValueType)!)
             } else {
                 return true
@@ -468,67 +497,78 @@ public final class Decoder {
         return false
     }
     
-    public func decodeInt32ForKey(key: UnsafePointer<Int8>) -> Int32 {
-        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.buffer.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Int32) {
+    public func decodeInt32ForKey(key: StaticString) -> Int32 {
+        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Int32) {
             var value: Int32 = 0
-            memcpy(&value, self.buffer.memory + self.buffer.offset, 4)
-            self.buffer.offset += 4
+            memcpy(&value, self.buffer.memory + self.offset, 4)
+            self.offset += 4
             return value
         } else {
             return 0
         }
     }
     
-    public func decodeInt32ForKey(key: UnsafePointer<Int8>) -> Int32? {
-        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.buffer.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Int32) {
+    public func decodeInt32ForKey(key: StaticString) -> Int32? {
+        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Int32) {
             var value: Int32 = 0
-            memcpy(&value, self.buffer.memory + self.buffer.offset, 4)
-            self.buffer.offset += 4
+            memcpy(&value, self.buffer.memory + self.offset, 4)
+            self.offset += 4
             return value
         } else {
             return nil
         }
     }
     
-    public func decodeInt64ForKey(key: UnsafePointer<Int8>) -> Int64 {
-        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.buffer.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Int64) {
+    public func decodeInt64ForKey(key: StaticString) -> Int64 {
+        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Int64) {
             var value: Int64 = 0
-            memcpy(&value, self.buffer.memory + self.buffer.offset, 8)
-            self.buffer.offset += 8
+            memcpy(&value, self.buffer.memory + self.offset, 8)
+            self.offset += 8
             return value
         } else {
             return 0
         }
     }
     
-    public func decodeBoolForKey(key: UnsafePointer<Int8>) -> Bool {
-        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.buffer.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Bool) {
+    public func decodeInt64ForKey(key: StaticString) -> Int64? {
+        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Int64) {
+            var value: Int64 = 0
+            memcpy(&value, self.buffer.memory + self.offset, 8)
+            self.offset += 8
+            return value
+        } else {
+            return nil
+        }
+    }
+    
+    public func decodeBoolForKey(key: StaticString) -> Bool {
+        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Bool) {
             var value: Int8 = 0
-            memcpy(&value, self.buffer.memory + self.buffer.offset, 1)
-            self.buffer.offset += 1
+            memcpy(&value, self.buffer.memory + self.offset, 1)
+            self.offset += 1
             return value != 0
         } else {
             return false
         }
     }
     
-    public func decodeDoubleForKey(key: UnsafePointer<Int8>) -> Double {
-        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.buffer.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Double) {
+    public func decodeDoubleForKey(key: StaticString) -> Double {
+        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Double) {
             var value: Double = 0
-            memcpy(&value, self.buffer.memory + self.buffer.offset, 8)
-            self.buffer.offset += 8
+            memcpy(&value, self.buffer.memory + self.offset, 8)
+            self.offset += 8
             return value
         } else {
             return 0
         }
     }
     
-    public func decodeStringForKey(key: UnsafePointer<Int8>) -> String {
-        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.buffer.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .String) {
+    public func decodeStringForKey(key: StaticString) -> String {
+        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .String) {
             var length: Int32 = 0
-            memcpy(&length, self.buffer.memory + self.buffer.offset, 4)
-            let data = NSData(bytes: self.buffer.memory + (self.buffer.offset + 4), length: Int(length))
-            self.buffer.offset += 4 + Int(length)
+            memcpy(&length, self.buffer.memory + self.offset, 4)
+            let data = NSData(bytes: self.buffer.memory + (self.offset + 4), length: Int(length))
+            self.offset += 4 + Int(length)
             let value = NSString(data: data, encoding: NSUTF8StringEncoding)
             return (value as? String) ?? ""
         } else {
@@ -536,12 +576,12 @@ public final class Decoder {
         }
     }
     
-    public func decodeStringForKey(key: UnsafePointer<Int8>) -> String? {
-        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.buffer.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .String) {
+    public func decodeStringForKey(key: StaticString) -> String? {
+        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .String) {
             var length: Int32 = 0
-            memcpy(&length, self.buffer.memory + self.buffer.offset, 4)
-            let data = NSData(bytes: self.buffer.memory + (self.buffer.offset + 4), length: Int(length))
-            self.buffer.offset += 4 + Int(length)
+            memcpy(&length, self.buffer.memory + self.offset, 4)
+            let data = NSData(bytes: self.buffer.memory + (self.offset + 4), length: Int(length))
+            self.offset += 4 + Int(length)
             let value = NSString(data: data, encoding: NSUTF8StringEncoding)
             return value as? String
         } else {
@@ -549,24 +589,24 @@ public final class Decoder {
         }
     }
 
-    public func decodeStringForKey(key: UnsafePointer<Int8>) -> DeferredString {
-        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.buffer.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .String) {
+    public func decodeStringForKey(key: StaticString) -> DeferredString {
+        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .String) {
             var length: Int32 = 0
-            memcpy(&length, self.buffer.memory + self.buffer.offset, 4)
-            let data = NSData(bytes: self.buffer.memory + (self.buffer.offset + 4), length: Int(length))
-            self.buffer.offset += 4 + Int(length)
+            memcpy(&length, self.buffer.memory + self.offset, 4)
+            let data = NSData(bytes: self.buffer.memory + (self.offset + 4), length: Int(length))
+            self.offset += 4 + Int(length)
             return DeferredStringValue(data)
         } else {
             return DeferredStringValue("")
         }
     }
     
-    public func decodeStringForKey(key: UnsafePointer<Int8>) -> DeferredString? {
-        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.buffer.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .String) {
+    public func decodeStringForKey(key: StaticString) -> DeferredString? {
+        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .String) {
             var length: Int32 = 0
-            memcpy(&length, self.buffer.memory + self.buffer.offset, 4)
-            let data = NSData(bytes: self.buffer.memory + (self.buffer.offset + 4), length: Int(length))
-            self.buffer.offset += 4 + Int(length)
+            memcpy(&length, self.buffer.memory + self.offset, 4)
+            let data = NSData(bytes: self.buffer.memory + (self.offset + 4), length: Int(length))
+            self.offset += 4 + Int(length)
             return DeferredStringValue(data)
         } else {
             return nil
@@ -577,17 +617,17 @@ public final class Decoder {
         return self.decodeObjectForKey("_")
     }
     
-    public func decodeObjectForKey(key: UnsafePointer<Int8>) -> Coding? {
-        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.buffer.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Object) {
+    public func decodeObjectForKey(key: StaticString) -> Coding? {
+        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Object) {
             var typeHash: Int32 = 0
-            memcpy(&typeHash, self.buffer.memory + self.buffer.offset, 4)
-            self.buffer.offset += 4
+            memcpy(&typeHash, self.buffer.memory + self.offset, 4)
+            self.offset += 4
             
             var length: Int32 = 0
-            memcpy(&length, self.buffer.memory + self.buffer.offset, 4)
+            memcpy(&length, self.buffer.memory + self.offset, 4)
 
-            let innerDecoder = Decoder(buffer: ReadBuffer(memory: self.buffer.memory + (self.buffer.offset + 4), length: Int(length), freeWhenDone: false))
-            self.buffer.offset += 4 + Int(length)
+            let innerDecoder = Decoder(buffer: ReadBuffer(memory: self.buffer.memory + (self.offset + 4), length: Int(length), freeWhenDone: false))
+            self.offset += 4 + Int(length)
             
             return typeStore.decode(typeHash, decoder: innerDecoder)
         } else {
@@ -595,17 +635,17 @@ public final class Decoder {
         }
     }
     
-    public func decodeObjectForKey(key: UnsafePointer<Int8>, decoder: Decoder -> Coding) -> Coding? {
-        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.buffer.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Object) {
+    public func decodeObjectForKey(key: StaticString, decoder: Decoder -> Coding) -> Coding? {
+        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Object) {
             var typeHash: Int32 = 0
-            memcpy(&typeHash, self.buffer.memory + self.buffer.offset, 4)
-            self.buffer.offset += 4
+            memcpy(&typeHash, self.buffer.memory + self.offset, 4)
+            self.offset += 4
             
             var length: Int32 = 0
-            memcpy(&length, self.buffer.memory + self.buffer.offset, 4)
+            memcpy(&length, self.buffer.memory + self.offset, 4)
             
-            let innerDecoder = Decoder(buffer: ReadBuffer(memory: self.buffer.memory + (self.buffer.offset + 4), length: Int(length), freeWhenDone: false))
-            self.buffer.offset += 4 + Int(length)
+            let innerDecoder = Decoder(buffer: ReadBuffer(memory: self.buffer.memory + (self.offset + 4), length: Int(length), freeWhenDone: false))
+            self.offset += 4 + Int(length)
             
             return decoder(innerDecoder)
         } else {
@@ -613,51 +653,51 @@ public final class Decoder {
         }
     }
     
-    public func decodeInt32ArrayForKey(key: UnsafePointer<Int8>) -> [Int32] {
-        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.buffer.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Int32Array) {
+    public func decodeInt32ArrayForKey(key: StaticString) -> [Int32] {
+        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Int32Array) {
             var length: Int32 = 0
-            memcpy(&length, self.buffer.memory + self.buffer.offset, 4)
+            memcpy(&length, self.buffer.memory + self.offset, 4)
             var array: [Int32] = []
             array.reserveCapacity(Int(length))
             var i: Int32 = 0
             while i < length {
                 var element: Int32 = 0
-                memcpy(&element, self.buffer.memory + (self.buffer.offset + 4 + 4 * Int(i)), 4)
+                memcpy(&element, self.buffer.memory + (self.offset + 4 + 4 * Int(i)), 4)
                 array.append(element)
                 i++
             }
-            self.buffer.offset += 4 + Int(length) * 4
+            self.offset += 4 + Int(length) * 4
             return array
         } else {
             return []
         }
     }
     
-    public func decodeInt64ArrayForKey(key: UnsafePointer<Int8>) -> [Int64] {
-        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.buffer.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Int64Array) {
+    public func decodeInt64ArrayForKey(key: StaticString) -> [Int64] {
+        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Int64Array) {
             var length: Int32 = 0
-            memcpy(&length, self.buffer.memory + self.buffer.offset, 4)
+            memcpy(&length, self.buffer.memory + self.offset, 4)
             var array: [Int64] = []
             array.reserveCapacity(Int(length))
             var i: Int32 = 0
             while i < length {
                 var element: Int64 = 0
-                memcpy(&element, self.buffer.memory + (self.buffer.offset + 4 + 8 * Int(i)), 8)
+                memcpy(&element, self.buffer.memory + (self.offset + 4 + 8 * Int(i)), 8)
                 array.append(element)
                 i++
             }
-            self.buffer.offset += 4 + Int(length) * 8
+            self.offset += 4 + Int(length) * 8
             return array
         } else {
             return []
         }
     }
     
-    public func decodeObjectArrayForKey<T: Coding>(key: UnsafePointer<Int8>) -> [T] {
-        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.buffer.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .ObjectArray) {
+    public func decodeObjectArrayForKey<T where T: Coding>(key: StaticString) -> [T] {
+        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .ObjectArray) {
             var length: Int32 = 0
-            memcpy(&length, self.buffer.memory + self.buffer.offset, 4)
-            self.buffer.offset += 4
+            memcpy(&length, self.buffer.memory + self.offset, 4)
+            self.offset += 4
             
             var array: [T] = []
             array.reserveCapacity(Int(length))
@@ -666,14 +706,14 @@ public final class Decoder {
             var i: Int32 = 0
             while i < length {
                 var typeHash: Int32 = 0
-                memcpy(&typeHash, self.buffer.memory + self.buffer.offset, 4)
-                self.buffer.offset += 4
+                memcpy(&typeHash, self.buffer.memory + self.offset, 4)
+                self.offset += 4
                 
                 var objectLength: Int32 = 0
-                memcpy(&objectLength, self.buffer.memory + self.buffer.offset, 4)
+                memcpy(&objectLength, self.buffer.memory + self.offset, 4)
                 
-                let innerDecoder = Decoder(buffer: ReadBuffer(memory: self.buffer.memory + (self.buffer.offset + 4), length: Int(objectLength), freeWhenDone: false))
-                self.buffer.offset += 4 + Int(objectLength)
+                let innerDecoder = Decoder(buffer: ReadBuffer(memory: self.buffer.memory + (self.offset + 4), length: Int(objectLength), freeWhenDone: false))
+                self.offset += 4 + Int(objectLength)
                 
                 if !failed {
                     if let object = typeStore.decode(typeHash, decoder: innerDecoder) as? T {
@@ -695,12 +735,55 @@ public final class Decoder {
             return []
         }
     }
-    
-    public func decodeObjectDictionaryForKey<K, V: Coding where K: Coding, K: Hashable>(key: UnsafePointer<Int8>) -> [K : V] {
-        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.buffer.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .ObjectDictionary) {
+
+    public func decodeObjectArrayForKey(key: StaticString) -> [Coding] {
+        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .ObjectArray) {
             var length: Int32 = 0
-            memcpy(&length, self.buffer.memory + self.buffer.offset, 4)
-            self.buffer.offset += 4
+            memcpy(&length, self.buffer.memory + self.offset, 4)
+            self.offset += 4
+            
+            var array: [Coding] = []
+            array.reserveCapacity(Int(length))
+            
+            var failed = false
+            var i: Int32 = 0
+            while i < length {
+                var typeHash: Int32 = 0
+                memcpy(&typeHash, self.buffer.memory + self.offset, 4)
+                self.offset += 4
+                
+                var objectLength: Int32 = 0
+                memcpy(&objectLength, self.buffer.memory + self.offset, 4)
+                
+                let innerDecoder = Decoder(buffer: ReadBuffer(memory: self.buffer.memory + (self.offset + 4), length: Int(objectLength), freeWhenDone: false))
+                self.offset += 4 + Int(objectLength)
+                
+                if !failed {
+                    if let object = typeStore.decode(typeHash, decoder: innerDecoder) {
+                        array.append(object)
+                    } else {
+                        failed = true
+                    }
+                }
+                
+                i++
+            }
+            
+            if failed {
+                return []
+            } else {
+                return array
+            }
+        } else {
+            return []
+        }
+    }
+    
+    public func decodeObjectDictionaryForKey<K, V: Coding where K: Coding, K: Hashable>(key: StaticString) -> [K : V] {
+        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .ObjectDictionary) {
+            var length: Int32 = 0
+            memcpy(&length, self.buffer.memory + self.offset, 4)
+            self.offset += 4
             
             var dictionary: [K : V] = [:]
             
@@ -708,26 +791,26 @@ public final class Decoder {
             var i: Int32 = 0
             while i < length {
                 var keyHash: Int32 = 0
-                memcpy(&keyHash, self.buffer.memory + self.buffer.offset, 4)
-                self.buffer.offset += 4
+                memcpy(&keyHash, self.buffer.memory + self.offset, 4)
+                self.offset += 4
                 
                 var keyLength: Int32 = 0
-                memcpy(&keyLength, self.buffer.memory + self.buffer.offset, 4)
+                memcpy(&keyLength, self.buffer.memory + self.offset, 4)
                 
-                var innerDecoder = Decoder(buffer: ReadBuffer(memory: self.buffer.memory + (self.buffer.offset + 4), length: Int(keyLength), freeWhenDone: false))
-                self.buffer.offset += 4 + Int(keyLength)
+                var innerDecoder = Decoder(buffer: ReadBuffer(memory: self.buffer.memory + (self.offset + 4), length: Int(keyLength), freeWhenDone: false))
+                self.offset += 4 + Int(keyLength)
                 
                 let key = failed ? nil : (typeStore.decode(keyHash, decoder: innerDecoder) as? K)
                     
                 var valueHash: Int32 = 0
-                memcpy(&valueHash, self.buffer.memory + self.buffer.offset, 4)
-                self.buffer.offset += 4
+                memcpy(&valueHash, self.buffer.memory + self.offset, 4)
+                self.offset += 4
                 
                 var valueLength: Int32 = 0
-                memcpy(&valueLength, self.buffer.memory + self.buffer.offset, 4)
+                memcpy(&valueLength, self.buffer.memory + self.offset, 4)
                 
-                innerDecoder = Decoder(buffer: ReadBuffer(memory: self.buffer.memory + (self.buffer.offset + 4), length: Int(valueLength), freeWhenDone: false))
-                self.buffer.offset += 4 + Int(valueLength)
+                innerDecoder = Decoder(buffer: ReadBuffer(memory: self.buffer.memory + (self.offset + 4), length: Int(valueLength), freeWhenDone: false))
+                self.offset += 4 + Int(valueLength)
                 
                 let value = failed ? nil : (typeStore.decode(valueHash, decoder: innerDecoder) as? V)
                 
@@ -750,12 +833,12 @@ public final class Decoder {
         }
     }
     
-    public func decodeBytesForKeyNoCopy(key: UnsafePointer<Int8>) -> ReadBuffer! {
-        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.buffer.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Bytes) {
+    public func decodeBytesForKeyNoCopy(key: StaticString) -> ReadBuffer! {
+        if Decoder.positionOnKey(UnsafePointer<Int8>(self.buffer.memory), offset: &self.offset, maxOffset: self.buffer.length, length: self.buffer.length, key: key, valueType: .Bytes) {
             var length: Int32 = 0
-            memcpy(&length, self.buffer.memory + self.buffer.offset, 4)
-            self.buffer.offset += 4 + Int(length)
-            return ReadBuffer(memory: UnsafeMutablePointer<Int8>(self.buffer.memory + (self.buffer.offset - Int(length))), length: Int(length), freeWhenDone: false)
+            memcpy(&length, self.buffer.memory + self.offset, 4)
+            self.offset += 4 + Int(length)
+            return ReadBuffer(memory: UnsafeMutablePointer<Int8>(self.buffer.memory + (self.offset - Int(length))), length: Int(length), freeWhenDone: false)
         } else {
             return nil
         }