How to translate tokens between NSData and NSString views in Swift?

Question

I have used the following Objective-C routines for many years to convert the NSData push token to NSString (for use by the push page service on the Internet) and the reverse to take a known version of the NSS token and update the NSData View. Now I find the need for the same features, but in Swift.

The DataToHex Objective-C code essentially uses printf formatting:

- (NSString *)dataToHex:(NSData *)data
{
    NSMutableString *str = [NSMutableString stringWithCapacity:100];
    const unsigned char *p = [data bytes];
    NSUInteger len = [data length];
    for(int i=0; i<len; ++i) {
      [str appendFormat:@"%02.2X", p[i]];
    }
    return str; 
}

Reverse translation:

- (NSData *)hexToData:(NSString *)str 
{
    const char *ptr = [str cStringUsingEncoding:NSASCIIStringEncoding];
    NSUInteger len = [str length]/2;
    NSMutableData *data = [NSMutableData dataWithCapacity:len];
    while(len--) {
        char num[5] = (char[]){ '0', 'x', 0, 0, 0 };
        num[2] = *ptr++;
        num[3] = *ptr++;
        uint8_t n = (uint8_t)strtol(num, NULL, 0);

        [data appendBytes:&n length:1];
    }
    return data;
}

Thanks to the smart overwriting of two bytes in an ASCII array, the string "0xXX" is converted to a byte, which is then added to the data object being modified.

Now that I am coding in Swift, I need the same features, but I have not found any messages with anything like the code above in Swift.

Answer 1

NSData, iOS, Objective C :

func dataToHex(data: NSData) -> String
{
    var str: String = String()
    let p = UnsafePointer<UInt8>(data.bytes)
    let len = data.length

    for var i=0; i<len; ++i {
        str += String(format: "%02.2X", p[i])
    }
    return str
}

, NSString, NSData . , , , .

, , , strtol:

func hexToData0(str: NSString) -> NSData {
    let len = str.length/2
    var data = NSMutableData(capacity:len)!
    var num: [Int8] = [ 0, 0, 0 ]
    let ptr = str.cStringUsingEncoding(NSUTF8StringEncoding)

    for var i=0; i<len; ++i {
        num[0] = ptr[i*2+0]
        num[1] = ptr[i*2+1]
        var n = UInt8 ( strtol(&num, nil, 16) )

        data.appendBytes(&n, length:1)
    }
    return data;
}

, strtol , , NSScanner, , , , :

func hexToData1(str: NSString) -> NSData {
    var data = NSMutableData(capacity: str.length/2)!
    for var i = 0; i<str.length; i+=2 {
        let r = NSRange(location: i, length: 2)
        let s = str.substringWithRange(r)
        let sc = NSScanner(string: s)

        var val: UInt32 = 0
        let ret = sc.scanHexInt(&val)
        if ret {
            var b = UInt8(val)
            data.appendBytes(&b, length: 1)
        } else {
            assert(false, "Yikes!")
        }
    }
    return data
}

, Swift, , , :

func hexToData(str: NSString) -> NSData {
    let len = str.length/2
    var data = NSMutableData(capacity:len)!
    let ptr = str.cStringUsingEncoding(NSUTF8StringEncoding)

    for var i=0; i<len; ++i {
        var num: UInt8 = 0
        var multi: UInt8 = 16;
        for var j=0; j<2; ++j {
            let c: UInt8 = UInt8(ptr[i*2+j])
            var offset: UInt8 = 0

            switch c {
            case 48...57:   // '0'-'9'
                offset = 48
            case 65...70:   // 'A'-'F'
                offset = 65 - 10         // 10 since 'A' is 10, not 0
            case 97...102:  // 'a'-'f'
                offset = 97 - 10         // 10 since 'a' is 10, not 0
            default:
                assert(false)
            }

            num += (c - offset)*multi
            multi = 1
        }
        data.appendBytes(&num, length:1)
    }
    return data;
}

hexToData .