Create mapping from string to class type in scala

Question

I have a lot of different external JSON entities that I want to parse to different internal case classs via json4s (scala). Everything works fine via the extract function from json4s. I have implemented a parse function which takes a type and a json string and parses the string to the type / the case class. To map the correct json string to the correct case class I have implemented a pattern matching function, which looks like this

entityName match {
 case "entity1" => JsonParser.parse[Entity1](jsonString)
 case "entity2" => JsonParser.parse[Entity2](jsonString)
 ....

I don't like the repetition here and would like to do this mapping via a map like this:

val mapping = Map(
 "entity1" -> Entity1,
 "entity2" -> Entity2
 ....

With this map in place I could implement the JsonParser.parse function only once like this

JsonParser.parse[mapping(entityName)](jsonString)

This is not working, because the map is referencing to the object and not to the class type. I also tried classOf[Entity1], but this also is not working. Is there a way to do this?

Thanks!

Well...You are mixing run-time stuff with compile-time stuff. — sarveshseri
– sarveshseri, Commented Dec 16, 2017 at 5:39

SergGr · Accepted Answer · 2017-12-16 05:47:15Z

The way you want your JsonParser.parse to work is not possible in Scala. Scala is a strongly and statically typed language. It means that the compiler should know the types of the values at the compile time to be able to verify that you accesss only valid fields and methods on them and/or pass them as valid parameters to methods. Assuming your classes are

case class Entity1(value:Int, unique1:Int)
case class Entity2(value:String, unique2:String)

and you write

val parsed = JsonParser.parse[mapping("entity1")](jsonString)

how the compiler could know the type of parsed to know the type of parsed.value or to know that parsed.unique1 is a valid field while parsed.unique2 is not? The best type compiler could assign to such parsed is something very generic like Any. Of course you can downcast that Any to the specific type later but this means you still have to specify that type explicitly in the asInstanceOf which kind of defeats the whole purpose. Still, if somehow returning Any is OK for you, you may try to do something like this:

import org.json4s.jackson.JsonMethods
implicit val formats = org.json4s.DefaultFormats // or whatever Formats you actually need

val typeMap: Map[String, scala.reflect.Manifest[_]] = Map(
  "String" -> implicitly[scala.reflect.Manifest[String]],
  "Int" -> implicitly[scala.reflect.Manifest[Int]]
)

def parseAny(typeName: String, jsonString: String): Any = {
  val jValue = JsonMethods.parse(jsonString)
  jValue.extract(formats, typeMap(typeName))
}

and then do something like this:

def testParseByTypeName(typeName: String, jsonString: String): Unit = {
  try {
    val parsed = parseAny(typeName, jsonString)
    println(s"parsed by name $typeName => ${parsed.getClass} - '$parsed'")
  } catch {
    case e => println(e)
  }
}

def test() = {
  testParseByTypeName("String", "\"abc\"")
  testParseByTypeName("Int", "123")
}

P.S. If your entityName doesn't come from the outside (i.e. you don't analyze data to find out actual type), you don't actually need it at all. It is enough to use type (without a need for match/case) such as:

def parse[T](jsonString: String)(implicit mf: scala.reflect.Manifest[T]): T = {
  val jValue = JsonMethods.parse(jsonString)
  jValue.extract[T]
}

def testParse[T](prefix: String, jsonString: String)(implicit mf: scala.reflect.Manifest[T]): Unit = {
  try {
    val parsed = parse[T](jsonString)
    println(s"$prefix => ${parsed.getClass} - '$parsed'")
  } catch {
    case e => println(e)
  }
}

def test() = {
  testParse[String]("parse String", "\"abc\"")
  testParse[Int]("parse Int", "123")
}

wibisono · Accepted Answer · 2017-12-17 00:08:55Z

0

Following idea from @SergGr, as a snippet to paste on Ammonite REPL:

{
    import $ivy.`org.json4s::json4s-native:3.6.0-M2`
    import org.json4s.native.JsonMethods.parse
    import org.json4s.DefaultFormats
    import org.json4s.JValue

    case class Entity1(name : String, value : Int)
    case class Entity2(name : String, value : Long)

    implicit val formats = DefaultFormats
    def extract[T](input : JValue)(implicit m : Manifest[T]) = input.extract[T]

    val mapping: Map[String, Manifest[_]] = Map(
        "entity1" -> implicitly[Manifest[Entity1]],
        "entity2" -> implicitly[Manifest[Entity2]]
      )

    val input = parse(""" { "name" : "abu", "value" : 1 } """)
    extract(input)(mapping("entity1")) //Entity1("abu", 1)
    extract(input)(mapping("entity2")) //Entity2("abu", 1L)
  }

edited Dec 17, 2017 at 0:08

answered Dec 16, 2017 at 23:54

wibisono

614 bronze badges

1 Comment

Lothium Over a year ago

Thanks, in combination with the answer from @SergGr it was really helpful.

Collectives™ on Stack Overflow

Create mapping from string to class type in scala

2 Answers 2

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related