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

scray.service.qmodel.thrifscala.ScrayTColumn.scala Maven / Gradle / Ivy

/**
 * Generated by Scrooge
 *   version: 4.16.0
 *   rev: 0201cac9fdd6188248d42da91fd14c87744cc4a5
 *   built at: 20170421-124523
 */
package scray.service.qmodel.thrifscala

import com.twitter.scrooge.{
  HasThriftStructCodec3,
  LazyTProtocol,
  TFieldBlob,
  ThriftException,
  ThriftStruct,
  ThriftStructCodec3,
  ThriftStructFieldInfo,
  ThriftStructMetaData,
  ThriftUtil
}
import org.apache.thrift.protocol._
import org.apache.thrift.transport.{TMemoryBuffer, TTransport}
import java.nio.ByteBuffer
import java.util.Arrays
import scala.collection.immutable.{Map => immutable$Map}
import scala.collection.mutable.Builder
import scala.collection.mutable.{
  ArrayBuffer => mutable$ArrayBuffer, Buffer => mutable$Buffer,
  HashMap => mutable$HashMap, HashSet => mutable$HashSet}
import scala.collection.{Map, Set}


object ScrayTColumn extends ThriftStructCodec3[ScrayTColumn] {
  private val NoPassthroughFields = immutable$Map.empty[Short, TFieldBlob]
  val Struct = new TStruct("ScrayTColumn")
  val ColumnInfoField = new TField("columnInfo", TType.STRUCT, 1)
  val ColumnInfoFieldManifest = implicitly[Manifest[scray.service.qmodel.thrifscala.ScrayTColumnInfo]]
  val ValueField = new TField("value", TType.STRING, 2)
  val ValueFieldManifest = implicitly[Manifest[ByteBuffer]]

  /**
   * Field information in declaration order.
   */
  lazy val fieldInfos: scala.List[ThriftStructFieldInfo] = scala.List[ThriftStructFieldInfo](
    new ThriftStructFieldInfo(
      ColumnInfoField,
      false,
      false,
      ColumnInfoFieldManifest,
      _root_.scala.None,
      _root_.scala.None,
      immutable$Map.empty[String, String],
      immutable$Map.empty[String, String],
      None
    ),
    new ThriftStructFieldInfo(
      ValueField,
      false,
      false,
      ValueFieldManifest,
      _root_.scala.None,
      _root_.scala.None,
      immutable$Map.empty[String, String],
      immutable$Map.empty[String, String],
      None
    )
  )

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

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

  def withoutPassthroughFields(original: ScrayTColumn): ScrayTColumn =
    new Immutable(
      columnInfo =
        {
          val field = original.columnInfo
          scray.service.qmodel.thrifscala.ScrayTColumnInfo.withoutPassthroughFields(field)
        },
      value =
        {
          val field = original.value
          field
        }
    )

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

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

    var columnInfo: scray.service.qmodel.thrifscala.ScrayTColumnInfo = null
    var value: ByteBuffer = null

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

    _iprot.readStructBegin()
    while (!_done) {
      val _field = _iprot.readFieldBegin()
      if (_field.`type` == TType.STOP) {
        _done = true
      } else {
        _field.id match {
          case 1 =>
            _field.`type` match {
              case TType.STRUCT =>
    
                columnInfo = readColumnInfoValue(_iprot)
              case _actualType =>
                val _expectedType = TType.STRUCT
                throw new TProtocolException(
                  "Received wrong type for field 'columnInfo' (expected=%s, actual=%s).".format(
                    ttypeToString(_expectedType),
                    ttypeToString(_actualType)
                  )
                )
            }
          case 2 =>
            _field.`type` match {
              case TType.STRING =>
    
                value = readValueValue(_iprot)
              case _actualType =>
                val _expectedType = TType.STRING
                throw new TProtocolException(
                  "Received wrong type for field 'value' (expected=%s, actual=%s).".format(
                    ttypeToString(_expectedType),
                    ttypeToString(_actualType)
                  )
                )
            }
          case _ =>
            if (_passthroughFields == null)
              _passthroughFields = immutable$Map.newBuilder[Short, TFieldBlob]
            _passthroughFields += (_field.id -> TFieldBlob.read(_field, _iprot))
        }
        _iprot.readFieldEnd()
      }
    }
    _iprot.readStructEnd()

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

  override def decode(_iprot: TProtocol): ScrayTColumn =
    _iprot match {
      case i: LazyTProtocol => lazyDecode(i)
      case i => eagerDecode(i)
    }

  private[this] def eagerDecode(_iprot: TProtocol): ScrayTColumn = {
    var columnInfo: scray.service.qmodel.thrifscala.ScrayTColumnInfo = null
    var value: ByteBuffer = null
    var _passthroughFields: Builder[(Short, TFieldBlob), immutable$Map[Short, TFieldBlob]] = null
    var _done = false

    _iprot.readStructBegin()
    while (!_done) {
      val _field = _iprot.readFieldBegin()
      if (_field.`type` == TType.STOP) {
        _done = true
      } else {
        _field.id match {
          case 1 =>
            _field.`type` match {
              case TType.STRUCT =>
                columnInfo = readColumnInfoValue(_iprot)
              case _actualType =>
                val _expectedType = TType.STRUCT
                throw new TProtocolException(
                  "Received wrong type for field 'columnInfo' (expected=%s, actual=%s).".format(
                    ttypeToString(_expectedType),
                    ttypeToString(_actualType)
                  )
                )
            }
          case 2 =>
            _field.`type` match {
              case TType.STRING =>
                value = readValueValue(_iprot)
              case _actualType =>
                val _expectedType = TType.STRING
                throw new TProtocolException(
                  "Received wrong type for field 'value' (expected=%s, actual=%s).".format(
                    ttypeToString(_expectedType),
                    ttypeToString(_actualType)
                  )
                )
            }
          case _ =>
            if (_passthroughFields == null)
              _passthroughFields = immutable$Map.newBuilder[Short, TFieldBlob]
            _passthroughFields += (_field.id -> TFieldBlob.read(_field, _iprot))
        }
        _iprot.readFieldEnd()
      }
    }
    _iprot.readStructEnd()

    new Immutable(
      columnInfo,
      value,
      if (_passthroughFields == null)
        NoPassthroughFields
      else
        _passthroughFields.result()
    )
  }

  def apply(
    columnInfo: scray.service.qmodel.thrifscala.ScrayTColumnInfo,
    value: ByteBuffer
  ): ScrayTColumn =
    new Immutable(
      columnInfo,
      value
    )

  def unapply(_item: ScrayTColumn): _root_.scala.Option[_root_.scala.Tuple2[scray.service.qmodel.thrifscala.ScrayTColumnInfo, ByteBuffer]] = _root_.scala.Some(_item.toTuple)


  @inline private def readColumnInfoValue(_iprot: TProtocol): scray.service.qmodel.thrifscala.ScrayTColumnInfo = {
    scray.service.qmodel.thrifscala.ScrayTColumnInfo.decode(_iprot)
  }

  @inline private def writeColumnInfoField(columnInfo_item: scray.service.qmodel.thrifscala.ScrayTColumnInfo, _oprot: TProtocol): Unit = {
    _oprot.writeFieldBegin(ColumnInfoField)
    writeColumnInfoValue(columnInfo_item, _oprot)
    _oprot.writeFieldEnd()
  }

  @inline private def writeColumnInfoValue(columnInfo_item: scray.service.qmodel.thrifscala.ScrayTColumnInfo, _oprot: TProtocol): Unit = {
    columnInfo_item.write(_oprot)
  }

  @inline private def readValueValue(_iprot: TProtocol): ByteBuffer = {
    _iprot.readBinary()
  }

  @inline private def writeValueField(value_item: ByteBuffer, _oprot: TProtocol): Unit = {
    _oprot.writeFieldBegin(ValueField)
    writeValueValue(value_item, _oprot)
    _oprot.writeFieldEnd()
  }

  @inline private def writeValueValue(value_item: ByteBuffer, _oprot: TProtocol): Unit = {
    _oprot.writeBinary(value_item)
  }


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

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

  /**
   * 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,
      val columnInfo: scray.service.qmodel.thrifscala.ScrayTColumnInfo,
      val value: ByteBuffer,
      override val _passthroughFields: immutable$Map[Short, TFieldBlob])
    extends ScrayTColumn {

    override def write(_oprot: TProtocol): Unit = {
      _oprot match {
        case i: LazyTProtocol => i.writeRaw(_buf, _start_offset, _end_offset - _start_offset)
        case _ => 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 = super.hashCode
  }

  /**
   * This Proxy trait allows you to extend the ScrayTColumn trait with additional state or
   * behavior and implement the read-only methods from ScrayTColumn using an underlying
   * instance.
   */
  trait Proxy extends ScrayTColumn {
    protected def _underlying_ScrayTColumn: ScrayTColumn
    override def columnInfo: scray.service.qmodel.thrifscala.ScrayTColumnInfo = _underlying_ScrayTColumn.columnInfo
    override def value: ByteBuffer = _underlying_ScrayTColumn.value
    override def _passthroughFields = _underlying_ScrayTColumn._passthroughFields
  }
}

trait ScrayTColumn
  extends ThriftStruct
  with _root_.scala.Product2[scray.service.qmodel.thrifscala.ScrayTColumnInfo, ByteBuffer]
  with HasThriftStructCodec3[ScrayTColumn]
  with java.io.Serializable
{
  import ScrayTColumn._

  def columnInfo: scray.service.qmodel.thrifscala.ScrayTColumnInfo
  def value: ByteBuffer

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

  def _1 = columnInfo
  def _2 = value

  def toTuple: _root_.scala.Tuple2[scray.service.qmodel.thrifscala.ScrayTColumnInfo, ByteBuffer] = {
    (
      columnInfo,
      value
    )
  }


  /**
   * 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] = {
    lazy val _buff = new TMemoryBuffer(32)
    lazy val _oprot = new TCompactProtocol(_buff)
    _passthroughFields.get(_fieldId) match {
      case blob: _root_.scala.Some[TFieldBlob] => blob
      case _root_.scala.None => {
        val _fieldOpt: _root_.scala.Option[TField] =
          _fieldId match {
            case 1 =>
              if (columnInfo ne null) {
                writeColumnInfoValue(columnInfo, _oprot)
                _root_.scala.Some(ScrayTColumn.ColumnInfoField)
              } else {
                _root_.scala.None
              }
            case 2 =>
              if (value ne null) {
                writeValueValue(value, _oprot)
                _root_.scala.Some(ScrayTColumn.ValueField)
              } else {
                _root_.scala.None
              }
            case _ => _root_.scala.None
          }
        _fieldOpt match {
          case _root_.scala.Some(_field) =>
            val _data = Arrays.copyOfRange(_buff.getArray, 0, _buff.length)
            _root_.scala.Some(TFieldBlob(_field, _data))
          case _root_.scala.None =>
            _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 { id -> _ } }).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): ScrayTColumn = {
    var columnInfo: scray.service.qmodel.thrifscala.ScrayTColumnInfo = this.columnInfo
    var value: ByteBuffer = this.value
    var _passthroughFields = this._passthroughFields
    _blob.id match {
      case 1 =>
        columnInfo = readColumnInfoValue(_blob.read)
      case 2 =>
        value = readValueValue(_blob.read)
      case _ => _passthroughFields += (_blob.id -> _blob)
    }
    new Immutable(
      columnInfo,
      value,
      _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): ScrayTColumn = {
    var columnInfo: scray.service.qmodel.thrifscala.ScrayTColumnInfo = this.columnInfo
    var value: ByteBuffer = this.value

    _fieldId match {
      case 1 =>
        columnInfo = null
      case 2 =>
        value = null
      case _ =>
    }
    new Immutable(
      columnInfo,
      value,
      _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.
   */
  def unsetColumnInfo: ScrayTColumn = unsetField(1)

  def unsetValue: ScrayTColumn = unsetField(2)


  override def write(_oprot: TProtocol): Unit = {
    ScrayTColumn.validate(this)
    _oprot.writeStructBegin(Struct)
    if (columnInfo ne null) writeColumnInfoField(columnInfo, _oprot)
    if (value ne null) writeValueField(value, _oprot)
    if (_passthroughFields.nonEmpty) {
      _passthroughFields.values.foreach { _.write(_oprot) }
    }
    _oprot.writeFieldStop()
    _oprot.writeStructEnd()
  }

  def copy(
    columnInfo: scray.service.qmodel.thrifscala.ScrayTColumnInfo = this.columnInfo,
    value: ByteBuffer = this.value,
    _passthroughFields: immutable$Map[Short, TFieldBlob] = this._passthroughFields
  ): ScrayTColumn =
    new Immutable(
      columnInfo,
      value,
      _passthroughFields
    )

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

  private def _equals(x: ScrayTColumn, y: ScrayTColumn): Boolean =
      x.productArity == y.productArity &&
      x.productIterator.sameElements(y.productIterator)

  override def equals(other: Any): Boolean =
    canEqual(other) &&
      _equals(this, other.asInstanceOf[ScrayTColumn]) &&
      _passthroughFields == other.asInstanceOf[ScrayTColumn]._passthroughFields

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

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


  override def productArity: Int = 2

  override def productElement(n: Int): Any = n match {
    case 0 => this.columnInfo
    case 1 => this.value
    case _ => throw new IndexOutOfBoundsException(n.toString)
  }

  override def productPrefix: String = "ScrayTColumn"

  def _codec: ThriftStructCodec3[ScrayTColumn] = ScrayTColumn
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy