All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.twitter.finagle.thrift.thriftscala.UpgradeReply.scala Maven / Gradle / Ivy

There is a newer version: 24.2.0
Show newest version
/**
 * Generated by Scrooge
 *   version: 20.4.1
 *   rev: 74d6bed636c90dc4b67e342ecd80033bad43e94d
 *   built at: 20200425-214521
 */
package com.twitter.finagle.thrift.thriftscala

import com.twitter.io.Buf
import com.twitter.scrooge.{
  InvalidFieldsException,
  LazyTProtocol,
  StructBuilder,
  StructBuilderFactory,
  TFieldBlob,
  ThriftStruct,
  ThriftStructCodec3,
  ThriftStructField,
  ThriftStructFieldInfo,
  ThriftStructMetaData,
  ValidatingThriftStruct,
  ValidatingThriftStructCodec3
}
import org.apache.thrift.protocol._
import org.apache.thrift.transport.TMemoryBuffer
import scala.collection.immutable.{Map => immutable$Map}
import scala.collection.mutable.Builder
import scala.reflect.{ClassTag, classTag}

/**
 * This is the struct that a successful upgrade will reply with.
 */
object UpgradeReply extends ValidatingThriftStructCodec3[UpgradeReply] with StructBuilderFactory[UpgradeReply] {
  val NoPassthroughFields: immutable$Map[Short, TFieldBlob] = immutable$Map.empty[Short, TFieldBlob]
  val Struct: TStruct = new TStruct("UpgradeReply")

  /**
   * Field information in declaration order.
   */
  val fieldInfos: scala.List[ThriftStructFieldInfo] = Nil

  val structAnnotations: immutable$Map[String, String] =
    immutable$Map.empty[String, String]

  private val fieldTypes: IndexedSeq[ClassTag[_]] = IndexedSeq[ClassTag[_]](
  )

  private[this] val structFields: Seq[ThriftStructField[UpgradeReply]] = Seq[ThriftStructField[UpgradeReply]](
  )

  override lazy val metaData: ThriftStructMetaData[UpgradeReply] =
    new ThriftStructMetaData(this, structFields, fieldInfos, Nil, structAnnotations)

  /**
   * Checks that all required fields are non-null.
   */
  def validate(_item: UpgradeReply): Unit = {
  }

  /**
   * Checks that the struct is a valid as a new instance. If there are any missing required or
   * construction required fields, return a non-empty list.
   */
  def validateNewInstance(item: UpgradeReply): scala.Seq[com.twitter.scrooge.validation.Issue] = {
    val buf = scala.collection.mutable.ListBuffer.empty[com.twitter.scrooge.validation.Issue]

    buf.toList
  }

  def withoutPassthroughFields(original: UpgradeReply): UpgradeReply =
    new Immutable(
    )

  def newBuilder(): StructBuilder[UpgradeReply] = new UpgradeReplyStructBuilder(_root_.scala.None, fieldTypes)

  override def encode(_item: UpgradeReply, _oproto: TProtocol): Unit = {
    _item.write(_oproto)
  }


  private[this] def lazyDecode(_iprot: LazyTProtocol): UpgradeReply = {


    var _passthroughFields: Builder[(Short, TFieldBlob), immutable$Map[Short, TFieldBlob]] = null
    var _done = false
    val _start_offset = _iprot.offset

    _iprot.readStructBegin()
    do {
      val _field = _iprot.readFieldBegin()
      val _fieldType = _field.`type`
      if (_fieldType == TType.STOP) {
        _done = true
      } else {
        _field.id match {
          case _ =>
            if (_passthroughFields eq null)
              _passthroughFields = immutable$Map.newBuilder[Short, TFieldBlob]
            _passthroughFields += _root_.scala.Tuple2(_field.id, TFieldBlob.read(_field, _iprot))
        }
        _iprot.readFieldEnd()
      }
    } while (!_done)
    _iprot.readStructEnd()

    new LazyImmutable(
      _iprot,
      _iprot.buffer,
      _start_offset,
      _iprot.offset,
      if (_passthroughFields eq null)
        NoPassthroughFields
      else
        _passthroughFields.result()
    )
  }

  override def decode(_iprot: TProtocol): UpgradeReply = {
    if (_iprot.isInstanceOf[LazyTProtocol]) {
      lazyDecode(_iprot.asInstanceOf[LazyTProtocol])
    } else {
      eagerDecode(_iprot)
    }
  }

  private[thriftscala] def eagerDecode(_iprot: TProtocol): UpgradeReply = {
    var _passthroughFields: Builder[(Short, TFieldBlob), immutable$Map[Short, TFieldBlob]] = null
    var _done = false

    _iprot.readStructBegin()
    do {
      val _field = _iprot.readFieldBegin()
      val _fieldType = _field.`type`
      if (_fieldType == TType.STOP) {
        _done = true
      } else {
            if (_passthroughFields eq null)
              _passthroughFields = immutable$Map.newBuilder[Short, TFieldBlob]
            _passthroughFields += _root_.scala.Tuple2(_field.id, TFieldBlob.read(_field, _iprot))
        _iprot.readFieldEnd()
      }
    } while (!_done)
    _iprot.readStructEnd()

    new Immutable(
      if (_passthroughFields eq null)
        NoPassthroughFields
      else
        _passthroughFields.result()
    )
  }

  def apply(
  ): UpgradeReply =
    new Immutable(
    )

  def unapply(_item: UpgradeReply): Boolean = true



  object Immutable extends ThriftStructCodec3[UpgradeReply] {
    override def encode(_item: UpgradeReply, _oproto: TProtocol): Unit = { _item.write(_oproto) }
    override def decode(_iprot: TProtocol): UpgradeReply = UpgradeReply.decode(_iprot)
    override lazy val metaData: ThriftStructMetaData[UpgradeReply] = UpgradeReply.metaData
  }

  /**
   * The default read-only implementation of UpgradeReply.  You typically should not need to
   * directly reference this class; instead, use the UpgradeReply.apply method to construct
   * new instances.
   */
  class Immutable(
      override val _passthroughFields: immutable$Map[Short, TFieldBlob])
    extends UpgradeReply {
    def this(
    ) = this(
      immutable$Map.empty[Short, TFieldBlob]
    )
  }

  /**
   * This is another Immutable, this however keeps strings as lazy values that are lazily decoded from the backing
   * array byte on read.
   */
  private[this] class LazyImmutable(
      _proto: LazyTProtocol,
      _buf: Array[Byte],
      _start_offset: Int,
      _end_offset: Int,
      override val _passthroughFields: immutable$Map[Short, TFieldBlob])
    extends UpgradeReply {

    override def write(_oprot: TProtocol): Unit = {
      if (_oprot.isInstanceOf[LazyTProtocol]) {
        _oprot.asInstanceOf[LazyTProtocol].writeRaw(_buf, _start_offset, _end_offset - _start_offset)
      } else {
        super.write(_oprot)
      }
    }


    /**
     * Override the super hash code to make it a lazy val rather than def.
     *
     * Calculating the hash code can be expensive, caching it where possible
     * can provide significant performance wins. (Key in a hash map for instance)
     * Usually not safe since the normal constructor will accept a mutable map or
     * set as an arg
     * Here however we control how the class is generated from serialized data.
     * With the class private and the contract that we throw away our mutable references
     * having the hash code lazy here is safe.
     */
    override lazy val hashCode: Int = super.hashCode
  }

  /**
   * This Proxy trait allows you to extend the UpgradeReply trait with additional state or
   * behavior and implement the read-only methods from UpgradeReply using an underlying
   * instance.
   */
  trait Proxy extends UpgradeReply {
    protected def _underlying_UpgradeReply: UpgradeReply
    override def _passthroughFields: immutable$Map[Short, TFieldBlob] = _underlying_UpgradeReply._passthroughFields
  }
}

/**
 * Prefer the companion object's [[com.twitter.finagle.thrift.thriftscala.UpgradeReply.apply]]
 * for construction if you don't need to specify passthrough fields.
 */
trait UpgradeReply
  extends ThriftStruct
  with _root_.scala.Product
  with ValidatingThriftStruct[UpgradeReply]
  with java.io.Serializable
{
  import UpgradeReply._


  def _passthroughFields: immutable$Map[Short, TFieldBlob] = immutable$Map.empty



  /**
   * Gets a field value encoded as a binary blob using TCompactProtocol.  If the specified field
   * is present in the passthrough map, that value is returned.  Otherwise, if the specified field
   * is known and not optional and set to None, then the field is serialized and returned.
   */
  def getFieldBlob(_fieldId: Short): _root_.scala.Option[TFieldBlob] = {
    val passedthroughValue = _passthroughFields.get(_fieldId)
    if (passedthroughValue.isDefined) {
      passedthroughValue
    } else {
      _root_.scala.None
    }
  }


  /**
   * Collects TCompactProtocol-encoded field values according to `getFieldBlob` into a map.
   */
  def getFieldBlobs(ids: TraversableOnce[Short]): immutable$Map[Short, TFieldBlob] =
    (ids.flatMap { id => getFieldBlob(id).map { fieldBlob => (id, fieldBlob) } }).toMap

  /**
   * Sets a field using a TCompactProtocol-encoded binary blob.  If the field is a known
   * field, the blob is decoded and the field is set to the decoded value.  If the field
   * is unknown and passthrough fields are enabled, then the blob will be stored in
   * _passthroughFields.
   */
  def setField(_blob: TFieldBlob): UpgradeReply = {
    var _passthroughFields = this._passthroughFields
    _blob.id match {
      case _ => _passthroughFields += _root_.scala.Tuple2(_blob.id, _blob)
    }
    new Immutable(
      _passthroughFields
    )
  }

  /**
   * If the specified field is optional, it is set to None.  Otherwise, if the field is
   * known, it is reverted to its default value; if the field is unknown, it is removed
   * from the passthroughFields map, if present.
   */
  def unsetField(_fieldId: Short): UpgradeReply = {
    new Immutable(
      _passthroughFields - _fieldId
    )
  }

  /**
   * If the specified field is optional, it is set to None.  Otherwise, if the field is
   * known, it is reverted to its default value; if the field is unknown, it is removed
   * from the passthroughFields map, if present.
   */

  override def write(_oprot: TProtocol): Unit = {
    UpgradeReply.validate(this)
    _oprot.writeStructBegin(Struct)
    if (_passthroughFields.nonEmpty) {
      _passthroughFields.values.foreach { _.write(_oprot) }
    }
    _oprot.writeFieldStop()
    _oprot.writeStructEnd()
  }

  def copy(
    _passthroughFields: immutable$Map[Short, TFieldBlob] = this._passthroughFields
  ): UpgradeReply =
    new Immutable(
      _passthroughFields
    )

  override def canEqual(other: Any): Boolean = other.isInstanceOf[UpgradeReply]

  private[this] def _equals(other: UpgradeReply): Boolean =
      this.productArity == other.productArity &&
      this.productIterator.sameElements(other.productIterator) &&
      this._passthroughFields == other._passthroughFields

  override def equals(other: Any): Boolean =
    canEqual(other) && _equals(other.asInstanceOf[UpgradeReply])

  override def hashCode: Int = {
    _root_.scala.runtime.ScalaRunTime._hashCode(this)
  }

  override def toString: String = _root_.scala.runtime.ScalaRunTime._toString(this)

  override def productArity: Int = 0

  override def productElement(n: Int): Any = throw new IndexOutOfBoundsException(_root_.java.lang.Integer.toString(n))

  override def productPrefix: String = "UpgradeReply"

  def _codec: ValidatingThriftStructCodec3[UpgradeReply] = UpgradeReply

  def newBuilder(): StructBuilder[UpgradeReply] = new UpgradeReplyStructBuilder(_root_.scala.Some(this), fieldTypes)
}

private[thriftscala] class UpgradeReplyStructBuilder(instance: _root_.scala.Option[UpgradeReply], fieldTypes: IndexedSeq[ClassTag[_]])
    extends StructBuilder[UpgradeReply](fieldTypes) {

  def build(): UpgradeReply = {
    UpgradeReply()
  }
}





© 2015 - 2024 Weber Informatics LLC | Privacy Policy