Agfdhyk

I would like to split a response which is in plain string. Response is as

Result Set, Status: N/A Host: somesite.com is Connection live: true Status Connection: deny heart beat: dead

Need to create a dictionary from this response like, ResultSetDic[String:String]

Status: N/A  

Host: somesite.com  

is Connection live: true  

Status Connection: deny  

heart beat: dead  

tried splitting the response string with various ways Like NSRegularExpression, Range, Split but none of them is cleaner and working multiple string result sets to parse one by one which is not neat.

Any helpful way to split the response in a dictionary.
In above response keys are always fixed.

Since you have a fixed format you're parsing, with known keys, and the same format every time, this is a ready made problem for Regular Expressions:

let input = "Result Set, Status: N/A Host: somesite.com is Connection live: true Status Connection: deny heart beat: dead"



extension String {

    subscript(range:NSRange) -> Substring {

        let start = index(startIndex, offsetBy: range.location)

        let end = index(start, offsetBy: range.length)



        return self[start..<end]

    }

}



func parse(response:String) -> [String:String]? {

    guard let regex = try? NSRegularExpression(pattern: "Result Set, Status: (.*) Host: (.*) is Connection live: (.*) Status Connection: (.*) heart beat: (.*)", options:) else {

        return nil

    }



    guard let match = regex.firstMatch(in: input, range:NSRange(input.startIndex..<input.endIndex, in: input)) else {

        return nil

    }



    // Note that a much better approach here would be to *not* return

    //  a dictionary, but instead to return a struct containing all

    //  of the relevant data

    return [

        "Status": String(input[match.range(at: 1)]),

        "Host": String(input[match.range(at:2)]),

        "is Connection live": String(input[match.range(at:3)]),

        "Status Connection": String(input[match.range(at: 4)]),

        "heart beat": String(input[match.range(at:5)])

    ]

}

The thing what makes this parsable is, that each value is only a single word and that key and value are separated by :.

First I identify the the end of the next key, then add the next word as its value.

func testing() {

    let input = "Result Set, Status: N/A Host: somesite.com is Connection live: true Status Connection: deny heart beat: dead"



    var  step1 = input.split(separator: " ")

    guard let index = step1.firstIndex(where: { $0.contains(",") }) else {

        fatalError("Does not contain `,`. at the beginning.")

    }

    step1.removeFirst(index + 1)



    var step2 = step1

    var output = [String: String]()

    repeat {

        guard let index = step2.firstIndex(where: { $0.contains(":") }) else {

            // If the last part has no :, can add it under `end`.

            // output["end"] = step2.joined(separator: " ")

            step2.removeAll()

            break

        }

        let key = step2[0...index].joined(separator: " ").trimmingCharacters(in: CharacterSet(charactersIn: ":"))

        let value = step2[index + 1]

        output [key] = String(value)

        step2.removeFirst(index + 2)



    } while step2.count != 0



    output.forEach{

        print("($0.key): ($0.value)")

    }

}





// Output:

// Host: somesite.com

// Status Connection: deny

// Status: N/A

// heart beat: dead

// is Connection live: true

Edit: Array.firstIndex(where:) seems to be Xcode10+, so in Xcode9.4 you may try:

extension Array {

    func firstIndex(where predicate: (Element) throws -> Bool) rethrows -> Int? {

        for index in indices where try predicate(self[index]) { return index }

        return nil

    }

}

Edit2: A backward-compatible way to add .firstIndex(where:) from Leo:

extension Collection {

    func firstIndex(where predicate: (Element) throws -> Bool) rethrows -> Index? {

        return try index(where: predicate)

    }

}

Since you have fixed keys and response format, it might be better go with specific parsing logics with your keys.

let response = "Result Set, Status: N/A Host: somesite.com is Connection live: true Status Connection: deny heart beat: dead"



enum ResponseParseId: String {

    case status = "Status:"

    case host = "Host:"

    case isConnectionLive = "is Connection live:"

    case statusConnection = "Status Connection:"

    case heartBeat = "heart beat:"



    var key: String {

        switch self {

        case .status:

            return "Status"

        case .host:

            return "Host"

        case .isConnectionLive:

            return "is Connection live"

        case .statusConnection:

            return "Status Connection"

        case .heartBeat:

            return "heart beat"

        }

    }



    static var allIds: [ResponseParseId] = [.status, .host, .isConnectionLive, .statusConnection, .heartBeat]

}



func getValue(from response: String, for key: ResponseParseId) -> String? {

    let components = response.components(separatedBy: key.rawValue)

    if let substring = components.last?.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines) {

        let subcomponents = substring.components(separatedBy: " ")

        if let value = subcomponents.first {

            return value

    }

}

return nil

}



func getResponseDictionary(response: String) -> [String: String] {

    var dictionary: [String: String] = [:]

    for id in ResponseParseId.allIds {

        if let value = getValue(from: response, for: id) {

            dictionary[id.key] = value

        }

    }

        return dictionary

    }



let dictionary = getResponseDictionary(response: response)



print(dictionary)