Question

I have some problem to cast my objeсt Variable[A] where A <: Array[_]

I create a function to compare manifest and cast data into Array to the good type.

My object Variable[A] store a Manifest[A] into the def 'type'

I make a plugin of an existent software, so it’s not me which instanciate this Variable with good type.

Prototype object and class :

object Prototype {
  def apply[T](n: String)(implicit t: Manifest[T]) = new Prototype[T] {
    val name = n
    val `type` = t
  }
}

trait Prototype[T] {
  def name: String
  def `type`: Manifest[T]
}

Variable Object and Class :

object Variable {
  def apply[T](p: Prototype[T], v: T) = new Variable[T] {
    val prototype = p
    val value = v
  }
}

trait Variable[T] {
  def prototype: Prototype[T]
  def value: T
}

My class which use :

class XYDataReader[A <: Array[_]](var data: Iterable[Variable[A]]) {

    def get[T](variable: Variable[A])(implicit m: Manifest[T]): Option[T] = {
        if (variable.prototype.`type` <:< m) {
          Some(variable.value.asInstanceOf[T])
        } else {
          None
        } 
}
}

There is probably a mistake of my part when i instanciate Variable object used to compare, so i give also the code of instanciation :

val v:List[Any] = List[Any](1.2,2,3)
val p = Prototype[Array[Any]]("col1")
val myVariable = Variable(p, v.toArray(ClassTag(p.`type`.runtimeClass)))

I don’t understand why pattern matching failed when i call get[Array[Double]](myVariable) where myVariable.value contain an Array[Double]

When i println() the two manifest :

• variable array type : Array[double]
• m type : Array[Double]

It seem an Array[Double] is not an Array[double], how can i resolve/cast this ?

Answer 1

Finally, with help of colleague methods to resursively unArrayify Array, i resolve my runtime type reification problem. Now i can compare equality between Array[double] with Array[Double].

  // Convert unknow A en Array[T], so you need to call get with Type :
  // example : get[Array[Double](myVariable)
  // return an Array[Double] only if it's possible for this Variable, else it return None
  def get[T](variable: Variable[A])(implicit m: Manifest[T]): Option[T] = {
    if (ClassUtils.assignable(variable.prototype.`type`.runtimeClass, m.runtimeClass)) {
      val casted = variable.prototype.`type`.runtimeClass.cast(variable.value)
      Some(casted.asInstanceOf[T])
    } else {
      None
    }

I hope these methods can help other people 🙂

You can see helping method ClassUtils.assignable here :

https://gist.github.com/4686167

and on the source forge project :

https://forge.iscpif.fr/projects/openmole/repository/revisions/master/entry/core/openmole/misc/org.openmole.misc.tools/src/main/scala/org/openmole/misc/tools/obj/ClassUtils.scala