org.coursera.courier.data.BytesArray.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of courier-runtime_2.12 Show documentation
courier-runtime
The newest version!


package org.coursera.courier.data

import javax.annotation.Generated

import com.linkedin.data.ByteString
import com.linkedin.data.DataList
import com.linkedin.data.DataMap
import com.linkedin.data.schema.ArrayDataSchema
import com.linkedin.data.schema.DataSchema
import com.linkedin.data.template.DataTemplateUtil
import com.linkedin.data.template.DataTemplate
import org.coursera.courier.companions.ArrayCompanion
import org.coursera.courier.templates.DataTemplates
import org.coursera.courier.templates.DataTemplates.DataConversion
import org.coursera.courier.templates.ScalaArrayTemplate
import scala.collection.GenTraversable
import scala.collection.JavaConverters._
import scala.collection.generic.CanBuildFrom
import scala.collection.mutable
import com.linkedin.data.template.Custom

@Generated(value = Array("BytesArray"), comments = "Courier Data Template.", date = "Fri Aug 14 14:51:38 PDT 2015")
final class BytesArray(private val dataList: DataList)
  extends IndexedSeq[ByteString]
  with Product
  with GenTraversable[ByteString]
  with DataTemplate[DataList]
  with ScalaArrayTemplate {

  override def length: Int = dataList.size()

  private[this] lazy val list = dataList.asScala.map(coerceInput)

  private[this] def coerceInput(any: AnyRef): ByteString = {

    DataTemplateUtil.coerceOutput(any, classOf[com.linkedin.data.ByteString])

  }

  override def apply(idx: Int): ByteString = list(idx)

  override def productElement(n: Int): Any = dataList.get(n)
  override def productArity: Int = dataList.size()

  override def schema(): DataSchema = BytesArray.SCHEMA

  override def data(): DataList = dataList
  override def copy(): DataTemplate[DataList] = this
  override def copy(dataList: DataList, conversion: DataConversion): ScalaArrayTemplate =
    BytesArray.build(dataList, conversion)
}

object BytesArray extends ArrayCompanion[BytesArray] {
  val SCHEMA = DataTemplateUtil.parseSchema("""{"type":"array","items":"bytes"}""").asInstanceOf[ArrayDataSchema]

  val empty = BytesArray()

  def apply(elems: ByteString*): BytesArray = {
    new BytesArray(new DataList(elems.map(coerceOutput).toList.asJava))
  }

  def apply(collection: Traversable[ByteString]): BytesArray = {
    new BytesArray(new DataList(collection.map(coerceOutput).toList.asJava))
  }

  def build(dataList: DataList, conversion: DataConversion): BytesArray = {
    new BytesArray(DataTemplates.makeImmutable(dataList, conversion))
  }

  def newBuilder = new DataBuilder()

  implicit val canBuildFrom = new CanBuildFrom[BytesArray, ByteString, BytesArray] {
    def apply(from: BytesArray) = new DataBuilder(from)
    def apply() = newBuilder
  }

  class DataBuilder(initial: BytesArray) extends mutable.Builder[ByteString, BytesArray] {
    def this() = this(new BytesArray(new DataList()))

    val elems = new DataList(initial.data())

    def +=(x: ByteString): this.type = {
      elems.add(coerceOutput(x))
      this
    }

    def clear() = {
      elems.clear()
    }

    def result() = {
      elems.makeReadOnly()
      new BytesArray(elems)
    }
  }

  private def coerceOutput(value: ByteString): AnyRef = {

    DataTemplateUtil.coerceInput(value, classOf[com.linkedin.data.ByteString], classOf[com.linkedin.data.ByteString])

  }

  implicit def wrap(traversable: Traversable[ByteString]): BytesArray = {
    BytesArray(traversable)
  }
}