def wrap[T]()

in scalding-base/src/main/scala/com/twitter/scalding/typed/HashEqualsArrayWrapper.scala [17:42]

• 16 lines of code
• 18 McCabe index (conditional complexity)

  def wrap[T](a: Array[T]): HashEqualsArrayWrapper[T] =
    wrapByClassFn[T](a.getClass.asInstanceOf[Class[Array[T]]])(a)

  /**
   * Creates a function that can be used to wrap Arrays into objects with valid equals() and hashCode()
   * methods.
   *
   * Using this method and applying it to many arrays should be faster than using wrap above on each array,
   * because this method uses reflection once, and wrap above uses reflection on each individual array.
   */
  def wrapByClassFn[T](clazz: Class[Array[T]]): Array[T] => HashEqualsArrayWrapper[T] = {

    val fn = clazz match {
      case c if classOf[Array[Long]].equals(c)    => a: Array[Long] => new HashEqualsLongArrayWrapper(a)
      case c if classOf[Array[Int]].equals(c)     => a: Array[Int] => new HashEqualsIntArrayWrapper(a)
      case c if classOf[Array[Short]].equals(c)   => a: Array[Short] => new HashEqualsShortArrayWrapper(a)
      case c if classOf[Array[Char]].equals(c)    => a: Array[Char] => new HashEqualsCharArrayWrapper(a)
      case c if classOf[Array[Byte]].equals(c)    => a: Array[Byte] => new HashEqualsByteArrayWrapper(a)
      case c if classOf[Array[Boolean]].equals(c) => a: Array[Boolean] => new HashEqualsBooleanArrayWrapper(a)
      case c if classOf[Array[Float]].equals(c)   => a: Array[Float] => new HashEqualsFloatArrayWrapper(a)
      case c if classOf[Array[Double]].equals(c)  => a: Array[Double] => new HashEqualsDoubleArrayWrapper(a)
      case c                                      => a: Array[T] => new HashEqualsObjectArrayWrapper(a)
    }

    fn.asInstanceOf[(Array[T] => HashEqualsArrayWrapper[T])]
  }