TrivalObjCEncoding.swift

fileprivate var boolEncoding: (Int8, Int8) = (0x42, 0x00)
fileprivate var int8Encoding: (Int8, Int8) = (0x63, 0x00)
fileprivate var uint8Encoding: (Int8, Int8) = (0x43, 0x00)
fileprivate var int16Encoding: (Int8, Int8) = (0x73, 0x00)
fileprivate var uint16Encoding: (Int8, Int8) = (0x53, 0x00)
fileprivate var int32Encoding: (Int8, Int8) = (0x69, 0x00)
fileprivate var uint32Encoding: (Int8, Int8) = (0x49, 0x00)
fileprivate var intEncoding: (Int8, Int8) = (0x6c, 0x00)
fileprivate var uintEncoding: (Int8, Int8) = (0x4c, 0x00)
fileprivate var int64Encoding: (Int8, Int8) = (0x71, 0x00)
fileprivate var uint64Encoding: (Int8, Int8) = (0x51, 0x00)
fileprivate var floatEncoding: (Int8, Int8) = (0x66, 0x00)
fileprivate var doubleEncoding: (Int8, Int8) = (0x64, 0x00)

// Note: these very carefully do the "wrong" thing by letting the address escape out
// we are safe since the ref is only made once and the values are inaccessable and
// never touched by anything else and addresses of global values...
// DO NOT TRY THIS AT HOME!

fileprivate let boolEncodingPtr: UnsafePointer<Int8> = {
    return withUnsafeMutableBytes(of: &boolEncoding) { (buffer) in
        return UnsafePointer(buffer.baseAddress!.assumingMemoryBound(to: Int8.self))
    }
}()

fileprivate let int8EncodingPtr: UnsafePointer<Int8> = {
    return withUnsafeMutableBytes(of: &int8Encoding) { (buffer) in
        return UnsafePointer(buffer.baseAddress!.assumingMemoryBound(to: Int8.self))
    }
}()

fileprivate let uint8EncodingPtr: UnsafePointer<Int8> = {
    return withUnsafeMutableBytes(of: &uint8Encoding) { (buffer) in
        return UnsafePointer(buffer.baseAddress!.assumingMemoryBound(to: Int8.self))
    }
}()

fileprivate let int16EncodingPtr: UnsafePointer<Int8> = {
    return withUnsafeMutableBytes(of: &int16Encoding) { (buffer) in
        return UnsafePointer(buffer.baseAddress!.assumingMemoryBound(to: Int8.self))
    }
}()

fileprivate let uint16EncodingPtr: UnsafePointer<Int8> = {
    return withUnsafeMutableBytes(of: &uint16Encoding) { (buffer) in
        return UnsafePointer(buffer.baseAddress!.assumingMemoryBound(to: Int8.self))
    }
}()

fileprivate let int32EncodingPtr: UnsafePointer<Int8> = {
    return withUnsafeMutableBytes(of: &int32Encoding) { (buffer) in
        return UnsafePointer(buffer.baseAddress!.assumingMemoryBound(to: Int8.self))
    }
}()

fileprivate let uint32EncodingPtr: UnsafePointer<Int8> = {
    return withUnsafeMutableBytes(of: &uint32Encoding) { (buffer) in
        return UnsafePointer(buffer.baseAddress!.assumingMemoryBound(to: Int8.self))
    }
}()

fileprivate let intEncodingPtr: UnsafePointer<Int8> = {
    return withUnsafeMutableBytes(of: &intEncoding) { (buffer) in
        return UnsafePointer(buffer.baseAddress!.assumingMemoryBound(to: Int8.self))
    }
}()

fileprivate let uintEncodingPtr: UnsafePointer<Int8> = {
    return withUnsafeMutableBytes(of: &uintEncoding) { (buffer) in
        return UnsafePointer(buffer.baseAddress!.assumingMemoryBound(to: Int8.self))
    }
}()

fileprivate let int64EncodingPtr: UnsafePointer<Int8> = {
    return withUnsafeMutableBytes(of: &int64Encoding) { (buffer) in
        return UnsafePointer(buffer.baseAddress!.assumingMemoryBound(to: Int8.self))
    }
}()

fileprivate let uint64EncodingPtr: UnsafePointer<Int8> = {
    return withUnsafeMutableBytes(of: &uint64Encoding) { (buffer) in
        return UnsafePointer(buffer.baseAddress!.assumingMemoryBound(to: Int8.self))
    }
}()

fileprivate let floatEncodingPtr: UnsafePointer<Int8> = {
    return withUnsafeMutableBytes(of: &floatEncoding) { (buffer) in
        return UnsafePointer(buffer.baseAddress!.assumingMemoryBound(to: Int8.self))
    }
}()

fileprivate let doubleEncodingPtr: UnsafePointer<Int8> = {
    return withUnsafeMutableBytes(of: &doubleEncoding) { (buffer) in
        return UnsafePointer(buffer.baseAddress!.assumingMemoryBound(to: Int8.self))
    }
}()

fileprivate struct _AnyType : Hashable {
    var type: Any.Type
    var hashValue: Int {
        return unsafeBitCast(type, to: UnsafeRawPointer.self).hashValue
    }
    static func ==(_ lhs: _AnyType, _ rhs: _AnyType) -> Bool {
        return lhs.type == rhs.type
    }
}

fileprivate let encodings: [_AnyType : UnsafePointer<Int8>] = [
    _AnyType(type: Bool.self) : boolEncodingPtr,
    _AnyType(type: Int8.self) : int8EncodingPtr,
    _AnyType(type: UInt8.self) : uint8EncodingPtr,
    _AnyType(type: Int16.self) : int16EncodingPtr,
    _AnyType(type: UInt16.self) : uint16EncodingPtr,
    _AnyType(type: Int32.self) : int32EncodingPtr,
    _AnyType(type: UInt32.self) : uint32EncodingPtr,
    _AnyType(type: Int.self) : intEncodingPtr,
    _AnyType(type: UInt.self) : uintEncodingPtr,
    _AnyType(type: Int64.self) : int64EncodingPtr,
    _AnyType(type: UInt64.self) : uint64EncodingPtr,
    _AnyType(type: Float.self) : floatEncodingPtr,
    _AnyType(type: Double.self) : doubleEncodingPtr,
]

// Simulates a very trivial @encode
internal func _trivialObjCEncode<T>(_ type: T.Type) -> UnsafePointer<Int8>? {
    return encodings[_AnyType(type: type)]
}