Swift UTF16 Substring

Question

I'm receiving a string from the server in the following format:

118|...message...215|...message2...

Basically, it's the message length followed by a pipe and the message itself, repeated for multiple messages. The message is encoded UTF16.

I'm looking for a way to parse this in Swift. I know I could cast this as NSString and use standard indexes/ranges on that because UTF16 is what NSString uses, but I'm wondering what is the Swift way to handle this? I can't seem to find a way to pull a substring out of a String based on a UTF16 encoding.

Update

I'm not trying to initialize a String with raw UTF16 Data (there's plenty of ways to do that). I already have the string, so I'm trying to take a String in the above format and parse it. The issue I have is that the message length given to me by the server is based on UTF16. I can't simply extract the length and call String.advance(messageLength) on the Index because the length I've been given doesn't match the grapheme clusters that Swift advances on. My issue is that I can't extract from the string the message in Swift. I have to instead cast it over to NSString and then use "normal" NSRange on it. My question is how do I pull the substring out by extracting a range based on my search for the first pipe, and then use the length provided by the parser in UTF16.

This is all extremely simple to do with NSString. Not sure how it can be done in pure Swift (or if it can be done).

Answer 1

Here is my take on parsing the messages out of the string. I had to change your lengths to work with the string.

let message = "13|...message...14|...message2..."
let utf16 = message.utf16
var startingIndex = message.utf16.startIndex
var travellingIndex = message.utf16.startIndex
var messages = [String]()
var messageLength: Int

while travellingIndex != message.utf16.endIndex {

    // Start walking through each character
    if let char = String(utf16[travellingIndex..<travellingIndex.successor()]) {

        // When we find the pipe symbol try to parse out the message length
        if char == "|" {
            if let stringNumber = Int(String(utf16[startingIndex..<travellingIndex])) {
                messageLength = stringNumber

                // We found the lenght, now skip the pipe character
                startingIndex = travellingIndex.successor()

                // move the travelingIndex to the end of the message
                travellingIndex = travellingIndex.advancedBy(messageLength)

                // get the message and put it into an array
                if let message = String(utf16[startingIndex...travellingIndex]) {
                    messages.append(message)
                    startingIndex = travellingIndex.successor()
                }
            }
        }
    }

    travellingIndex = travellingIndex.successor()
}

print(messages)

The output I get at the end is:

["...message...", "...message2..."]

Answer 2

The Foundation framework extends String to be initialisable from data:

import Foundation

let string = String(data: data, encoding: NSUTF16StringEncoding)

Getting rid of Foundation is not possible unless you implement the decoding yourself. Note that with Swift going open-source, Foundation is getting reimplemented without Objective-C dependency here.

EDIT: Thanks, Martin R, the link you provided is indeed working in pure Swift :D

EDIT:

There is the utf16 property of a String whose count property is the length in UTF16. Here is a simple parser for your purpose, efficiency isn't great, but it gets the job done:

func getMessages(var string: String) -> [String]? {

    func getMessage(string: String) -> (message: String, rest: String)? {
        guard let
            index = string.characters.indexOf("|"),
            length = Int(String(string.characters.prefixUpTo(index)))
        else { return nil }

        let msgRest = String(string.characters.suffixFrom(index.successor()))
        return (String(msgRest.utf16.prefix(length)), String(msgRest.utf16.dropFirst(length)))
    }

    var messages : [String] = []
    while let (message, rest) = getMessage(string) {
        string = rest
        messages.append(message)
    }
    return messages
}

func stringForMessages(messages: [String]) -> String {
    return messages.map{ "\($0.utf16.count)|\($0)" }.joinWithSeparator("")
}

let messages = [
    "123",
    "",
    "",
    "6⚽️"
]

let string = stringForMessages(messages)

let received = getMessages(string)

messages // ["123", "", "", "6⚽️"]

I actually tried making it more efficient, but Swift's String mechanics pushed against it.. I challenge anyone to create a beautiful efficient crash-safe parser for this..