name.remal.gradle_plugins.dsl.extensions.java.lang.Class.kt Maven / Gradle / Ivy

Go to download
package name.remal.gradle_plugins.dsl.extensions

import groovy.lang.Closure
import groovy.lang.MetaClass
import name.remal.findMethod
import name.remal.lambda.Function1
import name.remal.lambda.VoidFunction1
import name.remal.nullIf
import name.remal.uncheckedCast
import org.codehaus.groovy.runtime.DefaultGroovyMethods
import org.gradle.api.Action
import org.gradle.api.internal.GeneratedSubclass
import java.lang.reflect.Method
import java.util.function.Consumer
import kotlin.Array
import kotlin.Boolean
import kotlin.Int
import kotlin.RuntimeException
import kotlin.String
import kotlin.Throwable
import java.util.function.Function as JFunction
import kotlin.Function1 as KFunction1
import kotlin.reflect.KFunction1 as KReflectFunction1

val Class<*>.groovyMetaClass: MetaClass get() = DefaultGroovyMethods.getMetaClass(this)

val Class<*>.canBeConfigurer: Boolean
    get() = Action::class.java.isAssignableFrom(this)
        || Closure::class.java.isAssignableFrom(this)
        || Consumer::class.java.isAssignableFrom(this)
        || JFunction::class.java.isAssignableFrom(this)
        || KFunction1::class.java.isAssignableFrom(this)
        || KReflectFunction1::class.java.isAssignableFrom(this)
        || Function1::class.java.isAssignableFrom(this)
        || VoidFunction1::class.java.isAssignableFrom(this)


fun  Class.unwrapGradleGenerated(): Class {
    var clazz: Class<*> = this
    while (GeneratedSubclass::class.java.isAssignableFrom(clazz)) {
        clazz = clazz.superclass
    }
    return clazz.uncheckedCast()
}





/*
private val delegateClassOfCache: LoadingCache, Class<*>>, Class<*>> = CacheBuilder.newBuilder()
    .weakValues()
    .build(object : CacheLoader, Class<*>>, Class<*>>() {
        override fun load(key: Pair, Class<*>>): Class<*> {
            val (currentClass, delegateClass) = key
            val delegateFieldName = "\$\$delegate"
            val delegation = MethodDelegation.withEmptyConfiguration()
                .withResolvers(AmbiguityResolver.DEFAULT)
                .toField(delegateFieldName)
            return ByteBuddy()
                .subclass(currentClass, NO_CONSTRUCTORS)
                .name(currentClass.name + "\$\$Delegate\$" + delegateClass.name.replace('.', '_'))
                .defineField(delegateFieldName, delegateClass, PRIVATE, FINAL)
                .defineConstructor(PUBLIC).withParameter(delegateClass).intercept(
                    invoke((delegateClass.superclass ?: Any::class.java).getDeclaredConstructor())
                        .andThen(ofField(delegateFieldName).setsArgumentAt(0))
                )
                .withHashCodeEquals()
                .method(named("toString")).intercept(delegation)
                .method(any()).intercept(delegation) // FIXME: filter
                .make()
                .load(currentClass.classLoader)
                .loaded
        }
    })

fun  Class.getDelegateClassOf(other: Class<*>): Class {
    return delegateClassOfCache[this to other].uncheckedCast()
}

fun  Class.newDelegateOf(obj: Any): T {
    return getDelegateClassOf(obj.javaClass).getConstructor(obj.javaClass).newInstance(obj)
}
*/





fun Class<*>.findCompatibleMethod(name: String, returnType: Class<*>?, vararg paramTypes: Class<*>): Method? {
    if (paramTypes.isEmpty()) {
        return findMethod(name).nullIf { returnType != null && !returnType.isAssignableFrom([email protected]) }
    }

    val candidateMethods = methods.filter { method -> method.name == name && method.parameterCount == paramTypes.size && (returnType == null || returnType.isAssignableFrom(method.returnType)) }
    return candidateMethods.firstOrNull { method -> paramTypes.allIndexed { index, paramType -> method.parameterTypes[index] == paramType } }
        ?: candidateMethods.firstOrNull { method -> paramTypes.allIndexed { index, paramType -> method.parameterTypes[index].isAssignableFrom(paramType) } }
}

private inline fun  Array.allIndexed(predicate: (index: Int, element: T) -> Boolean): Boolean {
    forEachIndexed { index, element ->
        if (!predicate(index, element)) {
            return false
        }
    }
    return true
}

class CompatibleMethodNotFoundException : RuntimeException {
    constructor() : super()
    constructor(message: String?) : super(message)
    constructor(message: String?, cause: Throwable?) : super(message, cause)
    constructor(cause: Throwable?) : super(cause)
}