CODEWITHSUNDEEP
scalagenericsakka
htomek
htomek

Reputation: 256

Preserve type/class tag among akka messages

I have the situation where I want to preserve information about some generic type passed within a message to be able to create another generic class with that same type within receive method responsible for processing the message.

At first glance I thought TypeTag is my best friend here, but, after trying that out it seems this is not the best possible solution, or not solution at all. Let me first explain what I have at the moment and what is the outcome.

Message case class

trait MessageTypeTag[T] {
  def typeTag: TypeTag[T]
}

case class Message[T](id: Int, payload: T, helper: MyClass[T], 
                      cond: Condition[MyClass[T]])(implicit val typeTag: TypeTag[T])
           extends MessageTypeTag[T]

MyClass2

class MyClass2[+T <: Any](_eval: Option[T] = None) {
  def getEval = _eval getOrElse None
}

Receive method

def receive() = {
  case m@Message(id, payload, helper, cond) => {
    // this prints a proper type tag, i.e. String, because type is known in the runtime
    println(m.typeTag.tpe)

    // compiler complains here because it sees m.typeTag as TypeTag[Any], i.e. exact
    // type is not known in the compile time
    val temp = new MyClass2[m.typeTag.tpe](...)
 }
}

Dirty solution After reading several articles, discussions, documentation on both Scala and akka I come up with some dirty solution by putting the (call to) factory method case class.

case class Message[T](id: Int, payload: T, helper: MyClass[T], 
                      cond: Condition[MyClass[T]])(implicit val typeTag: TypeTag[T])
           extends MessageTypeTag[T] {
  def getMyClass2: MyClass2[T] = {
    // instantiate an object of type T
    val bla = typeTag.mirror.runtimeClass(typeTag.tpe).newInstance.asInstanceOf[T]
    // we can call apply here to populate created object or do whathever is needed
    ...
    // instantiate MyClass2 parametrized with type T and return it
    new MyClass2[T](Some(bla))
  }
}

As you can see this is far from good solution/design because this case class is all but lightweight and actually defeats the purpose of case class itself. It can be improved in a way that reflection call is not coded here but in some external factory which is just called within case class, but I have a feeling there must be a better approach to accomplish this.

Any suggestion would be very appreciated. If there are some more information needed, I can provide it.

And, I believe, similar problem/solution has been described here, but I'm wondering is there a better way. Thanks.

Upvotes: 3

Views: 304

Answers (1)

lmm
lmm

Reputation: 17431

If you want to be able to instantiate a class with reflection then you have to pass it around, there's no way around that. I think a ClassTag based solution is slightly simpler:

val bla = classTag.runtimeClass.newInstance.asInstanceOf[T]

but it's still pretty ugly.

It might be better to pass around a factory as a function rather than using a reflective approach; this lets you work with classes with no no-arg constructor or that require some setup:

case class Message[T](..., factory: () => T) {
  def getMyClass2 = new MyClass2[T](Some(factory()))
}

Message(..., {_ => new SomeTThatTakesArguments(3, 4)})

I suspect the best solution will be to change your MyClass2 so that it doesn't depend on the type in the same way - perhaps you can express the constraint MyClass2 needs as a typeclass you can include in the Message, or leave it out entirely. But you'll need to post MyClass2 if you want us to suggest a solution on those lines.

Upvotes: 1

Related Questions