Parsing and Updating Maps

Hello, and welcome back! Are you ready for a new challenge? In this unit, we're stepping up a notch to tackle a complex yet intriguing task. It involves parsing complex strings into Scala Maps and then updating them, a common requirement in many real-world tasks. So yes, this unit's session is going to be pretty pragmatic — just the way you like it!

This task involves transforming a given string into a nested Scala Map[String, Any] and updating a specific key-value pair within that map. The input string will take the form "Key1=Value1,Key2=Value2,...". When a part of the value is another key-value string, we create a nested map.

For example, the string "A1=B1,C1={D1=E1,F1=G1},I1=J1" should be transformed into the following nested map:

Map(
  "A1" -> "B1",
  "C1" -> Map(
    "D1" -> "E1",
    "F1" -> "G1"
  ),
  "I1" -> "J1"
)

Your Scala function should parse this string into the above map, then update the value of the nested key F1 from G1 to some other value, say "NewValue". The function should ultimately return the updated map.

Our first step here will be to parse the string into a nested map. Before diving into coding, let us understand that simple string splitting methods do not handle hierarchical structures well; hence, our solution needs to account for the nested nature of our text.

As you parse the string, you'll have to read through each character and note its role. Every time the = symbol is encountered, you can infer that the text bit you have on your hands is a key. Further, upon hitting the , symbol, you should gather that you've just finished reading a value. At this stage, it is safe to add the key-value pair you've just read into the map you're constructing.

The next step calls for special attention to the braces. When you encounter an opening brace {, you should know you are taking a step deeper into the hierarchy. On the other hand, when you encounter a closing brace }, you are taking a step back up.

Here is a Scala function that parses such a string into a nested Map[String, Any]:

def parseString(input: String): Map[String, Any] = {
  // Replace commas outside of curly braces with a special separator
  val sb = new StringBuilder
  var balance = 0
  for (c <- input) {
    c match {
      case '{' =>
        balance += 1
        sb.append(c)
      case '}' =>
        balance -= 1
        sb.append(c)
      case ',' if balance == 0 =>
        sb.append(';') // Use semicolon as separator at top level
      case _ =>
        sb.append(c)
    }
  }
  val preprocessed = sb.toString

  // Split into key-value elements
  val elements = preprocessed.split(";").toList.filter(_.nonEmpty)
  var result = Map[String, Any]()
  for (element <- elements) {
    val idx = element.indexOf("=")
    if (idx != -1) {
      val key = element.substring(0, idx)
      val value = element.substring(idx + 1)
      if (value.startsWith("{") && value.endsWith("}")) {
        // Value is a nested map
        val nested = parseString(value.substring(1, value.length - 1))
        result += (key -> nested)
      } else {
        result += (key -> value)
      }
    }
  }
  result
}