common/org.js.lolifamily.minecraftmcp.repl/MaskingClassLoader/SnippetLoader

SnippetLoader

The whole snippet chain in ONE hop: game-identity names to the game loader, the rest to masking, and only a miss in both retries a hybrid server's plugins (PluginBridge). One loader, not one per concern: every snippet class load walks this, and each level costs a lock + findLoadedClass.

Plugins stay last (so MC/mods/org.bukkit.* keep the server's identity, not a shaded copy) and out of loadClass, whose compiler lookups miss by design.

Constructors

SnippetLoader

constructor(masking: MaskingClassLoader, game: ClassLoader, redirectKotlin: Boolean)

Companion properties

nocerts

private val nocerts: Array<Certificate>

scl

private open var scl: ClassLoader

Companion functions

defineClass0

open fun defineClass0(p: ClassLoader, p1: Class<*>, p2: String, p3: Array<Byte>, p4: Int, p5: Int, p6: ProtectionDomain, p7: Boolean, p8: Int, p9: Any): Class<*>

defineClass1

open fun defineClass1(p: ClassLoader, p1: String, p2: Array<Byte>, p3: Int, p4: Int, p5: ProtectionDomain, p6: String): Class<*>

defineClass2

open fun defineClass2(p: ClassLoader, p1: String, p2: ByteBuffer, p3: Int, p4: Int, p5: ProtectionDomain, p6: String): Class<*>

findBootstrapClassOrNull

open fun findBootstrapClassOrNull(name: String): Class<*>

findNative

open fun findNative(loader: ClassLoader, clazz: Class<*>, entryName: String, javaName: String): Long

getBuiltinAppClassLoader

open fun getBuiltinAppClassLoader(): ClassLoader

getBuiltinPlatformClassLoader

open fun getBuiltinPlatformClassLoader(): ClassLoader

getClassLoader

open fun getClassLoader(caller: Class<*>): ClassLoader

getPlatformClassLoader

open fun getPlatformClassLoader(): ClassLoader

getSystemClassLoader

open fun getSystemClassLoader(): ClassLoader

getSystemResource

open fun getSystemResource(name: String): URL

getSystemResourceAsStream

open fun getSystemResourceAsStream(name: String): InputStream

getSystemResources

open fun getSystemResources(name: String): Enumeration<URL>

initSystemClassLoader

open fun initSystemClassLoader(): ClassLoader

loadLibrary

open fun loadLibrary(fromClass: Class<*>, file: File): NativeLibrary

nativeLibrariesFor

open fun nativeLibrariesFor(loader: ClassLoader): NativeLibraries

registerAsParallelCapable

protected open fun registerAsParallelCapable(): Boolean

Properties

assertionLock

val assertionLock: Any

classAssertionStatus

open var classAssertionStatus: Map<String, Boolean>

classes

private val classes: ArrayList<Class<*>>

classLoaderValueMap

private open var classLoaderValueMap: ConcurrentHashMap<*, *>

defaultAssertionStatus

private open var defaultAssertionStatus: Boolean

defaultDomain

private val defaultDomain: ProtectionDomain

game

private val game: ClassLoader

libraries

private val libraries: NativeLibraries

name

val name: String

nameAndId

private val nameAndId: String

package2certs

private val package2certs: ConcurrentHashMap<String, Array<Certificate>>

packageAssertionStatus

private open var packageAssertionStatus: Map<String, Boolean>

packages

private val packages: ConcurrentHashMap<String, NamedPackage>

parallelLockMap

private val parallelLockMap: ConcurrentHashMap<String, Any>

parent

val parent: ClassLoader

redirectKotlin

private val redirectKotlin: Boolean

unnamedModule

val unnamedModule: Module

Functions

addClass

open fun addClass(c: Class<*>)

clearAssertionStatus

open fun clearAssertionStatus()

createOrGetClassLoaderValueMap

open fun createOrGetClassLoaderValueMap(): ConcurrentHashMap<*, *>

defineClass

protected fun defineClass(b: Array<Byte>, off: Int, len: Int): Class<*>

definePackage

open fun definePackage(c: Class<*>): Package

desiredAssertionStatus

open fun desiredAssertionStatus(className: String): Boolean

findClass

protected open fun findClass(name: String): Class<*>

findLibrary

protected open fun findLibrary(libname: String): String

findLoadedClass

protected fun findLoadedClass(name: String): Class<*>

findResource

protected open fun findResource(moduleName: String, name: String): URL

findResources

protected open fun findResources(name: String): Enumeration<URL>

findSystemClass

protected fun findSystemClass(name: String): Class<*>

gameIdentity

private open fun gameIdentity(n: String): Boolean

Names that must be the GAME's copy, or a snippet value is a different class at the seam → LinkageError.

getClassLoadingLock

protected open fun getClassLoadingLock(className: String): Any

getDefinedPackage

fun getDefinedPackage(name: String): Package

getDefinedPackages

fun getDefinedPackages(): Array<Package>

getPackage

protected open fun getPackage(name: String): Package

getPackages

protected open fun getPackages(): Array<Package>

getResource

open fun getResource(name: String): URL

getResourceAsStream

open fun getResourceAsStream(name: String): InputStream

getResources

open fun getResources(name: String): Enumeration<URL>

isRegisteredAsParallelCapable

fun isRegisteredAsParallelCapable(): Boolean

load

private open fun load(name: String): Class<*>

Two shapes mean "not mine": the ordinary ClassNotFoundException, and a CLOSED loader — Bukkit closes a plugin's the moment its onDisable returns, and Paper's then report the shut jar from findClass as an IllegalStateException, which nothing downstream catches (not its own libraryLoader fallback either).

loadClass