CODEWITHSUNDEEP
scalagenericsreflectionmacrosscala-macros
mdedetrich
mdedetrich

Reputation: 1889

Getting field name and types from Case Class (with Option)

Assuming we have a model of something, represented as a case class, as so

case class User(firstName:String,lastName:String,age:Int,planet:Option[Planet])

sealed abstract class Planet
case object Earth extends Planet
case object Mars extends Planet
case object Venus extends Planet

Essentially, either by use of reflection, or Macros, to be able to get the field names of the User case class, as well as the types represented by the fields. This also includes Option, i.e. in the example provided, need to be able to differentiate between an Option[Planet] and just a Planet

In scala'ish pseudocode, something like this

val someMap = createTypedMap[User] // Assume createTypedMap is some function which returns map of Strings to Types
someMap.foreach{case(fieldName,someType) {
   val statement = someType match {
       case String => s"$fieldName happened to be a string"
       case Int => s"$fieldName happened to be an integer"
       case Planet => s"$fieldName happened to be a planet"
       case Option[Planet] => s"$fieldName happened to be an optional planet"
       case _ => s"unknown type for $fieldName"

   }
   println(statement)

}

I am currently aware that you can't do stuff like case Option[Planet], since it gets erased by Scala's erasure, however even when using TypeTags, I am unable to wrote code that does what I am trying to do, and possibly deal with other types (like Either[SomeError,String]).

Currently we are using the latest version of Scala (2.11.2) so any solution that uses TypeTags or ClassTags or macros would be more than enough.

Upvotes: 1

Views: 3267

Answers (1)

Diego Martinoia
Diego Martinoia

Reputation: 4662

Option is a type-parametrized type (Option[T]). At runtime, unless you have structured your code to use type tags, you have no mean to distinguish between an Option[String] and an Option[Int], due to type erasure (this is true for all type-parametrized types). Nonetheless, you can discriminate between an Option[*] and a Planet. Just keep in mind the first issue.

Through reflection, getting all the "things" inside a class is easy. For example, say you only want the getters (you can put other types of filters, there are A LOT of them, and not all behave as expected when inheritance is part of the process, so you'll need to experiment a little):

import reflect.runtime.{universe=>ru}
val fieldSymbols = ru.typeOf[User].members.collect{ 
    case m: ru.MethodSymbol if m.isGetter => m 
}

Another option you'd have, if you are calling the code on instances rather than on classes, is to go through every method, call the method and assign the result to a variable, and then test the type of the variable. This assumes that you are only calling methods that don't alter the state of the instance.

You have a lot of options, time for you to find the best one for your needs.

Upvotes: 1

Related Questions