Encode/Decode Scalar type and Array value in swift

encode.swift

func encode<T>(var value:T) -> NSData {
    let data = withUnsafePointer(&value){
        (ptr:UnsafePointer<T>) -> NSData in
        return NSData(bytes:ptr, length:sizeof(T.Type))
    }
    return data
}

func decode<T>(data:NSData) -> T {
    var ptr = UnsafeMutablePointer<T>.alloc(sizeof(T.Type))
    data.getBytes(ptr, length:data.length)
    let result = ptr.move()
    ptr.dealloc(sizeof(T.Type))
    return result
}

func encodeString(str:String) -> NSData {
    let u = str.unicodeScalars
    let c = count(u)
    let l = c * sizeof(UnicodeScalar)
    
    var ptr = UnsafeMutablePointer<UnicodeScalar>.alloc(c)
    var mapptr = UnsafeMutableBufferPointer(start:ptr, count:c)
    for (i, n) in enumerate(u) {
        mapptr[i] = n
    }
    let data = NSData(bytes:ptr, length:l)
    ptr.dealloc(c)
    return data
}

func decodeString(data:NSData) -> String {
    let l = data.length
    let c = l / sizeof(UnicodeScalar)
    var ptr = UnsafeMutablePointer<UnicodeScalar>.alloc(c)
    data.getBytes(ptr, length:l)
    var mapptr = UnsafeBufferPointer(start:ptr, count:c)
    let result = String(Array(mapptr).map{Character($0)})
    ptr.dealloc(c)
    return result
}


func encodeArray<C:CollectionType, T where C.Generator.Element == T>(var array:C) -> NSData {
    let c = array.count
    let l = sizeof(T.Type) * c
    let ptr = UnsafeMutablePointer<T>.alloc(c)
    let arrptr = UnsafeMutableBufferPointer(start:ptr, count:c)
    for (i, n) in enumerate(array) {
        arrptr[i] = n
    }

    let data = NSData(bytes:ptr, length:l)
    ptr.dealloc(c)
    return data
}

func decodeArray<T>(data:NSData) ->[T] {
    
    let l = data.length
    let c = l / sizeof(T.Type)
    
    let ptr = UnsafeMutablePointer<T>.alloc(c)
    data.getBytes(ptr, length:l)

    let mapptr = UnsafeBufferPointer<T>(start:ptr, count:c)
    let result = Array(mapptr)
    ptr.dealloc(c)
    return result
}