java.lang.reflect.Field Scala Examples

package com.hazelcast.Scala.serialization

import java.lang.reflect.{ Field, Modifier }

import scala.util.{ Failure, Success, Try }

import com.hazelcast.nio.{ ObjectDataInput, ObjectDataOutput, UnsafeHelper }

import sun.misc.Unsafe

private[serialization] object UnsafeSerializer {

  private[this] val UNSAFE = Try(Unsafe.getUnsafe) match {
    case Failure(_: SecurityException) | Success(null) => UnsafeHelper.UNSAFE.ensuring(_ != null, "Unable to obtain sun.misc.Unsafe")
    case Failure(e) => throw e
    case Success(unsafe) => unsafe
  }

  private def shouldSerialize(f: Field): Boolean =
    !Modifier.isStatic(f.getModifiers) &&
      !Modifier.isTransient(f.getModifiers)

  private def collectFields(cls: Class[_]): List[Field] = {
    if (cls != null) {
      val superFields = collectFields(cls.getSuperclass)
      val thisFields = cls.getDeclaredFields.filter(shouldSerialize).sortBy(_.getName)
      thisFields.foreach(_.setAccessible(true))
      thisFields ++: superFields
    } else Nil
  }

  private[this] val fields = new ClassValue[List[Field]] {
    def computeValue(cls: Class[_]): List[Field] = collectFields(cls)
  }

  def write(out: ObjectDataOutput, any: Any): Unit = {
    fields.get(any.getClass).foreach { field =>
      out.writeObject(field.get(any))
    }
  }
  private def collectInterfaceNames(cls: Class[_]): List[String] = {
    if (cls != null) {
      cls.getInterfaces.map(_.getName) ++: collectInterfaceNames(cls.getSuperclass)
    } else Nil
  }
  def read(inp: ObjectDataInput, cls: Class[_]): Any = {
    val instance = UNSAFE.allocateInstance(cls)
    fields.get(cls).foreach { field =>
      field.set(instance, inp.readObject[Any])
    }
    instance
  }
} 

package isabelle


import java.lang.reflect.{Method, Field}


object Untyped
{
  def method(c: Class[_], name: String, arg_types: Class[_]*): Method =
  {
    val m = c.getDeclaredMethod(name, arg_types: _*)
    m.setAccessible(true)
    m
  }

  def classes(obj: AnyRef): Iterator[Class[_ <: AnyRef]] = new Iterator[Class[_ <: AnyRef]] {
    private var next_elem: Class[_ <: AnyRef] = obj.getClass
    def hasNext(): Boolean = next_elem != null
    def next(): Class[_ <: AnyRef] = {
      val c = next_elem
      next_elem = c.getSuperclass.asInstanceOf[Class[_ <: AnyRef]]
      c
    }
  }

  def field(obj: AnyRef, x: String): Field =
  {
    val iterator =
      for {
        c <- classes(obj)
        field <- c.getDeclaredFields.iterator
        if field.getName == x
      } yield {
        field.setAccessible(true)
        field
      }
    if (iterator.hasNext) iterator.next
    else error("No field " + quote(x) + " for " + obj)
  }

  def get[A](obj: AnyRef, x: String): A =
    if (obj == null) null.asInstanceOf[A]
    else field(obj, x).get(obj).asInstanceOf[A]

  def set[A](obj: AnyRef, x: String, y: A): Unit =
    field(obj, x).set(obj, y)
} 

package isabelle


import java.lang.reflect.{Method, Field}


object Untyped
{
  def method(c: Class[_], name: String, arg_types: Class[_]*): Method =
  {
    val m = c.getDeclaredMethod(name, arg_types: _*)
    m.setAccessible(true)
    m
  }

  def classes(obj: AnyRef): Iterator[Class[_ <: AnyRef]] = new Iterator[Class[_ <: AnyRef]] {
    private var next_elem: Class[_ <: AnyRef] = obj.getClass
    def hasNext(): Boolean = next_elem != null
    def next(): Class[_ <: AnyRef] = {
      val c = next_elem
      next_elem = c.getSuperclass.asInstanceOf[Class[_ <: AnyRef]]
      c
    }
  }

  def field(obj: AnyRef, x: String): Field =
  {
    val iterator =
      for {
        c <- classes(obj)
        field <- c.getDeclaredFields.iterator
        if field.getName == x
      } yield {
        field.setAccessible(true)
        field
      }
    if (iterator.hasNext) iterator.next
    else error("No field " + quote(x) + " for " + obj)
  }

  def get[A](obj: AnyRef, x: String): A =
    if (obj == null) null.asInstanceOf[A]
    else field(obj, x).get(obj).asInstanceOf[A]

  def set[A](obj: AnyRef, x: String, y: A): Unit =
    field(obj, x).set(obj, y)
} 

package isabelle


import java.lang.reflect.{Method, Field}


object Untyped
{
  def method(c: Class[_], name: String, arg_types: Class[_]*): Method =
  {
    val m = c.getDeclaredMethod(name, arg_types: _*)
    m.setAccessible(true)
    m
  }

  def classes(obj: AnyRef): Iterator[Class[_ <: AnyRef]] = new Iterator[Class[_ <: AnyRef]] {
    private var next_elem: Class[_ <: AnyRef] = obj.getClass
    def hasNext(): Boolean = next_elem != null
    def next(): Class[_ <: AnyRef] = {
      val c = next_elem
      next_elem = c.getSuperclass.asInstanceOf[Class[_ <: AnyRef]]
      c
    }
  }

  def field(obj: AnyRef, x: String): Field =
  {
    val iterator =
      for {
        c <- classes(obj)
        field <- c.getDeclaredFields.iterator
        if field.getName == x
      } yield {
        field.setAccessible(true)
        field
      }
    if (iterator.hasNext) iterator.next
    else error("No field " + quote(x) + " for " + obj)
  }

  def get[A](obj: AnyRef, x: String): A =
    if (obj == null) null.asInstanceOf[A]
    else field(obj, x).get(obj).asInstanceOf[A]

  def set[A](obj: AnyRef, x: String, y: A): Unit =
    field(obj, x).set(obj, y)
} 

package org.apache.spark.sql.server.util

import java.io.File
import java.lang.reflect.Field
import java.util.StringTokenizer

import org.apache.spark.sql.internal.SQLConf
import org.apache.spark.sql.server.SQLServerConf._
import org.apache.spark.sql.server.SQLServerEnv
import org.apache.spark.util.Utils

object SQLServerUtils {

  
  def isTesting: Boolean = {
    SQLServerEnv.sparkConf.contains("spark.sql.server.testing") &&
      SQLServerEnv.sparkConf.get("spark.sql.server.testing") == "true"
  }

  def isRunningOnYarn(conf: SQLConf): Boolean = {
    conf.settings.get("spark.master").startsWith("yarn")
  }

  def isKerberosEnabled(conf: SQLConf): Boolean = {
    require(!conf.sqlServerImpersonationEnabled || conf.sqlServerExecutionMode == "multi-context",
      "Impersonation can be enabled in multi-context mode only")
    conf.contains("spark.yarn.keytab") && conf.contains("spark.yarn.principal")
  }

  def kerberosKeytab(conf: SQLConf): String = {
    val key = "spark.yarn.keytab"
    val keytabFilename = conf.getConfString(key)
    require(keytabFilename != null, s"Kerberos requires `$key` to be provided.")
    keytabFilename
  }

  def kerberosPrincipal(conf: SQLConf): String = {
    val key = "spark.yarn.principal"
    val principalName = conf.getConfString(key)
    require(principalName != null, s"Kerberos requires `$key` to be provided.")
    principalName
  }

  def findFileOnClassPath(fileName: String): Option[File] = {
    val classpath = System.getProperty("java.class.path")
    val pathSeparator = System.getProperty("path.separator")
    val tokenizer = new StringTokenizer(classpath, pathSeparator)
    while (tokenizer.hasMoreTokens) {
      val pathElement = tokenizer.nextToken()
      val directoryOrJar = new File(pathElement)
      val absoluteDirectoryOrJar = directoryOrJar.getAbsoluteFile
      if (absoluteDirectoryOrJar.isFile) {
        val target = new File(absoluteDirectoryOrJar.getParent, fileName)
        if (target.exists()) {
          return Some(target)
        }
      } else {
        val target = new File(directoryOrJar, fileName)
        if (target.exists()) {
          return Some(target)
        }
      }
    }
    None
  }

  // https://blog.sebastian-daschner.com/entries/changing_env_java
  def injectEnvVar(key: String, value: String): Unit = {
    val clazz = Utils.classForName("java.lang.ProcessEnvironment")
    injectIntoUnmodifiableMap(key, value, clazz)
  }

  private def getDeclaredField(clazz: Class[_], fieldName: String): Field = {
    val field = clazz.getDeclaredField(fieldName)
    field.setAccessible(true)
    field
  }

  private def injectIntoUnmodifiableMap(key: String, value: String, clazz: Class[_]): Unit = {
    val unmodifiableEnvField = getDeclaredField(clazz, "theUnmodifiableEnvironment")
    val unmodifiableEnv = unmodifiableEnvField.get(null)
    val unmodifiableMapClazz = Utils.classForName("java.util.Collections$UnmodifiableMap")
    val field = getDeclaredField(unmodifiableMapClazz, "m")
    field.get(unmodifiableEnv).asInstanceOf[java.util.Map[String, String]].put(key, value)
  }
} 

package bloomfilter

import bloomfilter.hashing.MurmurHash3Generic

import java.lang.reflect.Field

trait CanGenerateHashFrom[From] {
  def generateHash(from: From): Long
}

object CanGenerateHashFrom {
  implicit case object CanGenerateHashFromLong extends CanGenerateHashFrom[Long] {
    override def generateHash(from: Long): Long = MurmurHash3Generic.fmix64(from)
  }

  implicit case object CanGenerateHashFromByteArray extends CanGenerateHashFrom[Array[Byte]] {
    override def generateHash(from: Array[Byte]): Long =
      MurmurHash3Generic.murmurhash3_x64_64(from, 0, from.length, 0)
  }

  import bloomfilter.util.Unsafe.unsafe

  case object CanGenerateHashFromString extends CanGenerateHashFrom[String] {
    private val valueOffset = unsafe.objectFieldOffset(stringValueField)

    override def generateHash(from: String): Long = {
      val value = unsafe.getObject(from, valueOffset).asInstanceOf[Array[Char]]
      MurmurHash3Generic.murmurhash3_x64_64(value, 0, from.length * 2, 0)
    }
  }

  case object CanGenerateHashFromStringByteArray extends CanGenerateHashFrom[String] {
    private val valueOffset = unsafe.objectFieldOffset(stringValueField)

    override def generateHash(from: String): Long = {
      val value = unsafe.getObject(from, valueOffset).asInstanceOf[Array[Byte]]
      MurmurHash3Generic.murmurhash3_x64_64(value, 0, from.length, 0)
    }
  }

  private val stringValueField: Field = classOf[String].getDeclaredField("value")
  implicit val canGenerateHashFromString: CanGenerateHashFrom[String] = {
    if (stringValueField.getType.getComponentType == java.lang.Byte.TYPE) CanGenerateHashFromStringByteArray else CanGenerateHashFromString
  }
} 

package bloomfilter

import bloomfilter.hashing.MurmurHash3Generic

import java.lang.reflect.Field

trait CanGenerate128HashFrom[From] {
  def generateHash(from: From): (Long, Long)
}

object CanGenerate128HashFrom {
  implicit case object CanGenerate128HashFromLong extends CanGenerate128HashFrom[Long] {
    override def generateHash(from: Long): (Long, Long) = {
      val hash = MurmurHash3Generic.fmix64(from)
      (hash, hash)
    }
  }

  implicit case object CanGenerate128HashFromByteArray extends CanGenerate128HashFrom[Array[Byte]] {
    override def generateHash(from: Array[Byte]): (Long, Long) =
      MurmurHash3Generic.murmurhash3_x64_128(from, 0, from.length, 0)
  }

  import bloomfilter.util.Unsafe.unsafe

  case object CanGenerate128HashFromString extends CanGenerate128HashFrom[String] {
    private val valueOffset = unsafe.objectFieldOffset(stringValueField)

    override def generateHash(from: String): (Long, Long) = {
      val value = unsafe.getObject(from, valueOffset).asInstanceOf[Array[Char]]
      MurmurHash3Generic.murmurhash3_x64_128(value, 0, from.length * 2, 0)
    }
  }

  case object CanGenerate128HashFromStringByteArray extends CanGenerate128HashFrom[String] {
    private val valueOffset = unsafe.objectFieldOffset(stringValueField)

    override def generateHash(from: String): (Long, Long) = {
      val value = unsafe.getObject(from, valueOffset).asInstanceOf[Array[Byte]]
      MurmurHash3Generic.murmurhash3_x64_128(value, 0, from.length, 0)
    }
  }

  private val stringValueField: Field = classOf[String].getDeclaredField("value")
  implicit val canGenerate128HashFromString: CanGenerate128HashFrom[String] = {
    if (stringValueField.getType.getComponentType == java.lang.Byte.TYPE) CanGenerate128HashFromStringByteArray else CanGenerate128HashFromString
  }
} 

package com.hazelcast.Scala.serialization

import com.hazelcast.internal.serialization.impl.ObjectDataInputStream
import com.hazelcast.internal.serialization.{InternalSerializationService => SerializationService}
import java.lang.reflect.Field
import com.hazelcast.nio.serialization.HazelcastSerializationException
import com.hazelcast.nio.ObjectDataInput

private[serialization] object ObjectDataInputStreamProxy {
  private[this] val SerSvcClass = classOf[SerializationService]
  private[this] val SerSvcField = new ClassValue[Field] {
    def computeValue(cls: Class[_]): Field = {
      val field = findField(cls)
      field setAccessible true
      field
    }
    private def findField(cls: Class[_]): Field = {
      if (cls == null) throw new HazelcastSerializationException(s"Cannot find field for $SerSvcClass")
      else {
        val maybeField = cls.getDeclaredFields.find(fld => SerSvcClass.isAssignableFrom(fld.getType))
        maybeField getOrElse findField(cls.getSuperclass)
      }
    }
  }
  private[this] def getSerializationService(out: ObjectDataInput): SerializationService = {
    val field = SerSvcField.get(out.getClass)
    field.get(out).asInstanceOf[SerializationService]
  }
  def apply(is: ByteArrayInputStream, inp: ObjectDataInput) = new ObjectDataInputStream(is, getSerializationService(inp))
} 

package com.hazelcast.Scala.serialization

import com.hazelcast.internal.serialization.impl.ObjectDataOutputStream
import com.hazelcast.internal.serialization.{ InternalSerializationService => SerializationService }
import java.lang.reflect.Field
import com.hazelcast.nio.serialization.HazelcastSerializationException
import com.hazelcast.nio.ObjectDataOutput

private[serialization] object ObjectDataOutputStreamProxy {
  private[this] val SerSvcClass = classOf[SerializationService]
  private[this] val SerSvcField = new ClassValue[Field] {
    def computeValue(cls: Class[_]): Field = {
      val field = findField(cls)
      field setAccessible true
      field
    }
    private def findField(cls: Class[_]): Field = {
      if (cls == null) throw new HazelcastSerializationException(s"Cannot find field for $SerSvcClass")
      else {
        val maybeField = cls.getDeclaredFields.find(fld => SerSvcClass.isAssignableFrom(fld.getType))
        maybeField getOrElse findField(cls.getSuperclass)
      }
    }
  }
  private[this] def getSerializationService(out: ObjectDataOutput): SerializationService = {
    val field = SerSvcField.get(out.getClass)
    field.get(out).asInstanceOf[SerializationService]
  }
  def apply(os: ByteArrayOutputStream, out: ObjectDataOutput) = new ObjectDataOutputStreamProxy(os, getSerializationService(out))
}
private[serialization] class ObjectDataOutputStreamProxy(
  os: ByteArrayOutputStream,
  ss: SerializationService)
    extends ObjectDataOutputStream(os, ss) 

package com.webank.wedatasphere.linkis.rpc.sender

import java.lang.reflect.Field

import com.netflix.client.ClientRequest
import com.netflix.client.config.IClientConfig
import com.netflix.loadbalancer.reactive.LoadBalancerCommand
import com.webank.wedatasphere.linkis.common.ServiceInstance
import com.webank.wedatasphere.linkis.common.conf.{Configuration => DWCConfiguration}
import com.webank.wedatasphere.linkis.protocol.Protocol
import com.webank.wedatasphere.linkis.rpc.interceptor.{BaseRPCInterceptorChain, RPCInterceptor, RPCLoadBalancer, ServiceInstanceRPCInterceptorChain}
import com.webank.wedatasphere.linkis.rpc.transform.RPCConsumer
import com.webank.wedatasphere.linkis.rpc.{BaseRPCSender, RPCMessageEvent, RPCSpringBeanCache}
import com.webank.wedatasphere.linkis.server.{BDPJettyServerHelper, Message}
import feign._
import org.apache.commons.lang.StringUtils
import org.springframework.cloud.netflix.ribbon.ServerIntrospector
import org.springframework.cloud.openfeign.ribbon.{CachingSpringLoadBalancerFactory, FeignLoadBalancer, LoadBalancerFeignClient}


  override def deliver(message: Any): Unit = getRPCSenderListenerBus.post(RPCMessageEvent(message, serviceInstance))

  override def equals(obj: Any): Boolean = if(obj == null) false
    else obj match {
      case sender: SpringMVCRPCSender => sender.serviceInstance == serviceInstance
      case _ => false
    }

  override def hashCode(): Int = serviceInstance.hashCode()

  override val toString: String = if(StringUtils.isBlank(serviceInstance.getInstance)) s"RPCSender(${serviceInstance.getApplicationName})"
    else s"RPCSender($getApplicationName, ${serviceInstance.getInstance})"
}
private object SpringMVCRPCSender {
  private var requestField: Field = _
  def getRequest(req: ClientRequest): Request = {
    if(requestField == null) synchronized {
      if(requestField == null) {
        requestField = req.getClass.getDeclaredField("request")
        requestField.setAccessible(true)
      }
    }
    requestField.get(req).asInstanceOf[Request]
  }
} 

package io.fintrospect.templating

import java.io.Writer
import java.lang.reflect.{Field, Method}

import com.github.mustachejava.Iteration
import com.github.mustachejava.reflect.ReflectionObjectHandler

import scala.collection.JavaConversions.mapAsJavaMap
import scala.reflect.ClassTag
import scala.runtime.BoxedUnit

class ScalaObjectHandler extends ReflectionObjectHandler {

  override def checkMethod(member: Method) {}

  override def checkField(member: Field) {}

  override def coerce(value: AnyRef) = value match {
    case m: collection.Map[_, _] => mapAsJavaMap(m)
    case _: BoxedUnit => null
    case Some(some: AnyRef) => coerce(some)
    case None => null
    case _ => value
  }

  override def iterate(iteration: Iteration, writer: Writer, value: AnyRef, scopes: java.util.List[AnyRef]) = value match {
    case TraversableAnyRef(t) => {
      var newWriter = writer
      t foreach (next => newWriter = iteration.next(newWriter, coerce(next), scopes))
      newWriter
    }
    case n: Number => if (n.intValue() == 0) writer else iteration.next(writer, coerce(value), scopes)
    case _ => super.iterate(iteration, writer, value, scopes)
  }

  override def falsey(iteration: Iteration, writer: Writer, value: AnyRef, scopes: java.util.List[AnyRef]) = value match {
    case TraversableAnyRef(t) => if (t.isEmpty) iteration.next(writer, value, scopes) else writer
    case n: Number => if (n.intValue() == 0) iteration.next(writer, coerce(value), scopes) else writer
    case _ => super.falsey(iteration, writer, value, scopes)
  }

  private val TraversableAnyRef = new Def[Traversable[AnyRef]]

  private class Def[C: ClassTag] {
    def unapply[X: ClassTag](x: X): Option[C] = x match {
      case c: C => Some(c)
      case _ => None
    }
  }

} 

package io.github.mandar2812.dynaml.utils.sumac

import annotation.tailrec
import java.lang.reflect.{Type, ParameterizedType, Field}

import scala.reflect.ClassTag


object ReflectionUtils {

  @tailrec
  def getAllDeclaredFields(cls: Class[_], acc: Seq[Field] = Seq.empty): Seq[Field] = {
    val fields = acc ++ cls.getDeclaredFields
    Option(cls.getSuperclass) match {
      case Some(clazz) => getAllDeclaredFields(clazz, fields)
      case _ => fields
    }
  }

  def findGenericInterface(cls: Class[_], interface: Class[_]) : Option[ParameterizedType] = {
    val interfaces = cls.getGenericInterfaces
    //first check if this directly implements it
    findParameterizedType(interfaces, interface).orElse{
      //then check if its inherited by any of those interfaces
      interfaces.flatMap{tpe =>
        findGenericInterface(getRawClass(tpe), interface)
      }.headOption
    }
  }

  def getRawClass(tpe: Type) : Class[_] = {
    tpe match {
      case x: Class[_] => x
      case p: ParameterizedType => p.getRawType.asInstanceOf[Class[_]]
    }
  }

  def findParameterizedType(types: Array[Type], interface: Class[_]) : Option[ParameterizedType] = {
    types.find { tpe =>
      tpe match {
        case ptpe: ParameterizedType => ParseHelper.checkType(ptpe, classOf[Argable[_]])
        case _ => false
      }
    }.map{_.asInstanceOf[ParameterizedType]}
  }

  def construct[T](clz: Class[T]): T = {
    val ctors = clz.getDeclaredConstructors
    ctors.find(_.getGenericParameterTypes.length == 0) match {
      case Some(ctor) =>
        ctor.setAccessible(true)
        ctor.newInstance().asInstanceOf[T]
      case None => throw new AssertionError("No zero-arg constructor found")
    }
  }

  def construct[T](tag: ClassTag[T]): T = {
    construct(tag.runtimeClass.asInstanceOf[Class[T]])
  }
} 

package com.comcast.money.aspectj

import java.lang.reflect.Field
import java.util.concurrent._

import com.comcast.money.core.concurrent.TraceFriendlyThreadPoolExecutor
import org.aspectj.lang.ProceedingJoinPoint
import org.aspectj.lang.annotation.{ Aspect, Around, Pointcut }
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor

import scala.util.Try

@Aspect
class ThreadPoolTaskExecutorAspect {
  def getField(clazz: Class[_], fieldName: String): Option[Field] = {

    if (clazz == classOf[Object])
      None
    else
      Try(clazz.getDeclaredField(fieldName)).toOption.orElse(getField(clazz.getSuperclass, fieldName))
  }

  def getFieldValue[T](instance: AnyRef, fieldName: String): T = {
    getField(instance.getClass, fieldName).map(
      f => {
        f.setAccessible(true)
        f.get(instance).asInstanceOf[T]
      }).getOrElse(null.asInstanceOf[T])
  }

  def setFieldValue[T](instance: AnyRef, fieldName: String, value: T) = {
    getField(instance.getClass, fieldName).map(
      f => {
        f.setAccessible(true)
        f.set(instance, value)
      })
  }

  @Pointcut(
    "execution(* org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor+.initializeExecutor(java.util.concurrent.ThreadFactory, java.util.concurrent.RejectedExecutionHandler)) && args(threadFactory,rejectedExecutionHandler)")
  def initializeExecutor(threadFactory: ThreadFactory, rejectedExecutionHandler: RejectedExecutionHandler) = {}

  @Around("initializeExecutor(threadFactory, rejectedExecutionHandler)")
  def aroundInitializeExector(joinPoint: ProceedingJoinPoint, threadFactory: ThreadFactory,
    rejectedExecutionHandler: RejectedExecutionHandler): AnyRef = {
    val self = joinPoint.getThis.asInstanceOf[ThreadPoolTaskExecutor]

    val queueCapacity: Int = getFieldValue(self, "queueCapacity")
    val corePoolSize: Int = getFieldValue(self, "corePoolSize")
    val maxPoolSize: Int = getFieldValue(self, "maxPoolSize")
    val keepAliveSeconds: Int = getFieldValue(self, "keepAliveSeconds")
    val allowCoreThreadTimeOut: Boolean = getFieldValue(self, "allowCoreThreadTimeOut")

    val queue: BlockingQueue[Runnable] =
      if (queueCapacity > 0) {
        new LinkedBlockingQueue[Runnable](queueCapacity)
      } else {
        new SynchronousQueue[Runnable]
      }

    val executor: ThreadPoolExecutor = new TraceFriendlyThreadPoolExecutor(
      corePoolSize, maxPoolSize, keepAliveSeconds, TimeUnit.SECONDS, queue, threadFactory, rejectedExecutionHandler)
    if (allowCoreThreadTimeOut) {
      executor.allowCoreThreadTimeOut(true)
    }

    setFieldValue(self, "threadPoolExecutor", executor)

    executor
  }
} 

package wvlet.airframe.canvas
import sun.misc.Unsafe


private[canvas] object UnsafeUtil {
  // Fetch theUnsafe object for Oracle and OpenJDK
  private[canvas] val unsafe = {
    import java.lang.reflect.Field
    val field: Field = classOf[Unsafe].getDeclaredField("theUnsafe")
    field.setAccessible(true)
    field.get(null).asInstanceOf[Unsafe]
  }

  if (unsafe == null)
    throw new RuntimeException("Unsafe is unavailable")

  private[canvas] val arrayByteBaseOffset: Long = unsafe.arrayBaseOffset(classOf[Array[Byte]])
  private[canvas] val arrayByteIndexScale: Int  = unsafe.arrayIndexScale(classOf[Array[Byte]])

  // Make sure the VM thinks bytes are only one byte wide
  if (arrayByteIndexScale != 1)
    throw new IllegalStateException("Byte array index scale must be 1, but is " + arrayByteIndexScale)
} 

package ru.tinkoff.gatling.amqp.request

import java.lang.reflect.Field

import com.rabbitmq.client.AMQP
import com.softwaremill.quicklens._

case class AmqpProtocolMessage(amqpProperties: AMQP.BasicProperties,
                               payload: Array[Byte],
                               responseCode: Option[String] = None) {

  def mergeProperties(props: Map[String, Any]): AmqpProtocolMessage = {
    this
      .modify(_.amqpProperties)
      .using(
        amqpProps =>
          amqpProps.getClass.getDeclaredFields.foldLeft(amqpProps)(
            (p, field) => forceModify(p, field, props.getOrElse(field.getName, null))
        ))
  }

  private def forceModify[T, V](obj: T, field: Field, fieldValue: V): T = {
    if (field.canAccess(obj)) {
      field.set(obj, fieldValue)
    } else {
      field.setAccessible(true)
      field.set(obj, fieldValue)
      field.setAccessible(false)
    }
    obj
  }

  def correlationId(newValue: String): AmqpProtocolMessage =
    this.copy(amqpProperties = amqpProperties.builder.correlationId(newValue).build)

  def correlationId: String = amqpProperties.getCorrelationId

  def messageId(newValue: String): AmqpProtocolMessage =
    this.copy(amqpProperties = amqpProperties.builder.messageId(newValue).build)

  def messageId: String = amqpProperties.getMessageId
} 

package com.kakao.mango.reflect

import java.lang.reflect.{Constructor, Method, Field}
import java.lang.reflect.Modifier._

import scala.reflect._


object Accessible {

  val modifiers: Field = {
    val field = classOf[Field].getDeclaredField("modifiers")
    field.setAccessible(true)
    field
  }

  def field[T: ClassTag](name: String): Field = {
    field(classTag[T].runtimeClass, name)
  }

  def field(clazz: Class[_], name: String): Field = {
    val field = clazz.getDeclaredField(name)
    field.setAccessible(true)
    modifiers.setInt(field, field.getModifiers & ~FINAL)
    field
  }

  def method[T: ClassTag](name: String, parameterTypes: Class[_]*): Method = {
    method(classTag[T].runtimeClass, name, parameterTypes: _*)
  }

  def method(clazz: Class[_], name: String, parameterTypes: Class[_]*): Method = {
    val method = clazz.getDeclaredMethod(name, parameterTypes: _*)
    method.setAccessible(true)
    method
  }

  def constructor[T](clazz: Class[T], parameterTypes: Class[_]*): Constructor[T] = {
    val constructor = clazz.getDeclaredConstructor(parameterTypes: _*)
    constructor.setAccessible(true)
    constructor
  }

  def firstConstructor[T: ClassTag]: Constructor[T] = {
    firstConstructor(classTag[T].runtimeClass.asInstanceOf[Class[T]])
  }

  def firstConstructor[T](clazz: Class[T]): Constructor[T] = {
    val constructor = clazz.getDeclaredConstructors()(0).asInstanceOf[Constructor[T]]
    constructor.setAccessible(true)
    constructor
  }

} 

package com.kakao.shaded.jackson.module.scala
package introspect

import util.Implicits._
import java.lang.reflect.{AccessibleObject, Constructor, Field, Method}

import scala.language.existentials

case class ConstructorParameter(constructor: Constructor[_], index: Int, defaultValueMethod: Option[Method])

case class PropertyDescriptor(name: String,
                              param: Option[ConstructorParameter],
                              field: Option[Field],
                              getter: Option[Method],
                              setter: Option[Method],
                              beanGetter: Option[Method],
                              beanSetter: Option[Method])
{
  if (List(field, getter).flatten.isEmpty) throw new IllegalArgumentException("One of field or getter must be defined.")

  def findAnnotation[A <: java.lang.annotation.Annotation](implicit mf: Manifest[A]): Option[A] = {
    val cls = mf.runtimeClass.asInstanceOf[Class[A]]
    lazy val paramAnnotation = (param flatMap { cp =>
      val paramAnnos = cp.constructor.getParameterAnnotations
      paramAnnos(cp.index).find(cls.isInstance)
    }).asInstanceOf[Option[A]]
    val getAnno = (o: AccessibleObject) => o.getAnnotation(cls)
    lazy val fieldAnnotation = field optMap getAnno
    lazy val getterAnnotation = getter optMap getAnno
    lazy val beanGetterAnnotation = beanGetter optMap getAnno

    paramAnnotation orElse fieldAnnotation orElse getterAnnotation orElse beanGetterAnnotation
  }

}