com.twitter.bijection.protobuf.ProtobufCodecs.scala Maven / Gradle / Ivy

Go to download
package com.twitter.bijection.protobuf

import com.twitter.bijection.{Bijection, Conversion, Injection, InversionFailure}
import com.twitter.bijection.Inversion.attempt
import com.google.protobuf.Message
import com.google.protobuf.ProtocolMessageEnum
import java.lang.{Integer => JInt}
import scala.collection.mutable.{Map => MMap}
import scala.util.{Failure, Success}
import scala.reflect._

/**
  * Bijections for use in serializing and deserializing Protobufs.
  */
object ProtobufCodec {

  /**
    * For scala instantiation. Uses reflection.
    */
  implicit def apply[T <: Message: ClassTag]: Injection[T, Array[Byte]] = {
    val klass = classTag[T].runtimeClass.asInstanceOf[Class[T]]
    fromClass(klass)
  }

  /**
    * For java instantiation. No reflection, supplied classes only.
    */
  def fromClass[T <: Message](klass: Class[T]): Injection[T, Array[Byte]] =
    new ProtobufCodec[T](klass)
}

class ProtobufCodec[T <: Message](klass: Class[T]) extends Injection[T, Array[Byte]] {
  lazy val parseFrom = klass.getMethod("parseFrom", classOf[Array[Byte]])
  override def apply(item: T) = item.toByteArray
  override def invert(bytes: Array[Byte]) = attempt(bytes) { bytes =>
    parseFrom.invoke(null, bytes).asInstanceOf[T]
  }
}

object ProtobufEnumCodec {

  /**
    * For scala instantiation. Uses reflection.
    */
  implicit def apply[T <: ProtocolMessageEnum: ClassTag]: Injection[T, Int] = {
    val klass = classTag[T].runtimeClass.asInstanceOf[Class[T]]
    fromClass(klass)
  }

  /**
    * For java instantiation. No reflection, supplied classes only.
    */
  def fromClass[T <: ProtocolMessageEnum](klass: Class[T]): Injection[T, Int] =
    new ProtobufEnumCodec[T](klass)

  /**
    * Implicit conversions between ProtocolMessageEnum and common types.
    */
  implicit def toBinary[T <: ProtocolMessageEnum: ClassTag]: Injection[T, Array[Byte]] =
    Injection.connect[T, Int, Array[Byte]]
}

class ProtobufEnumCodec[T <: ProtocolMessageEnum](klass: Class[T]) extends Injection[T, Int] {
  import Conversion.asMethod // adds "as" for conversions

  lazy val valueOf = klass.getMethod("valueOf", classOf[Int])
  val cache = MMap[Int, T]()
  override def apply(enum: T) = enum.getNumber
  override def invert(i: Int) =
    Option {
      cache.getOrElseUpdate(i, valueOf.invoke(null, i.as[JInt]).asInstanceOf[T])
    }.toRight(InversionFailure(i)).fold(Failure(_), Success(_))
}