serverpackcreator-api/de.griefed.serverpackcreator.api/ApiPlugins

ApiPlugins

Manager for ServerPackCreator plugins. In itself it doesn't do much. It gathers lists of all available extensions for TabExtension,PreGenExtension,PreZipExtension and PostGenExtension so they can then be run during server pack generation and during initialization of the GUI.

Author

Griefed

actual class ApiPlugins(tomlParser: TomlParser, apiProperties: ApiProperties, versionMeta: VersionMeta, utilities: Utilities) : JarPluginManager

Author

Griefed

Parameters

tomlParser

To read plugin-configurations, so they can be provided to extensions.

apiProperties

ServerPackCreator settings to be provided to extensions.

versionMeta

Version meta to be provided to extensions.

utilities

Utilities to be provided to extensions.

Constructors

ApiPlugins

constructor(tomlParser: TomlParser, apiProperties: ApiProperties, versionMeta: VersionMeta, utilities: Utilities)

Properties

dependencyResolver

protected var dependencyResolver: DependencyResolver

exactVersionAllowed

protected var exactVersionAllowed: Boolean

extensionFactory

protected var extensionFactory: ExtensionFactory

extensionFinder

protected var extensionFinder: ExtensionFinder

pluginClassLoaders

protected var pluginClassLoaders: MutableMap<String, ClassLoader>

pluginDescriptorFinder

protected var pluginDescriptorFinder: PluginDescriptorFinder

pluginFactory

protected var pluginFactory: PluginFactory

pluginLoader

protected var pluginLoader: PluginLoader

pluginRepository

protected var pluginRepository: PluginRepository

plugins

protected var plugins: MutableMap<String, PluginWrapper>

pluginsRoots

protected val pluginsRoots: MutableList<Path>

pluginStateListeners

protected var pluginStateListeners: MutableList<PluginStateListener>

pluginStatusProvider

protected var pluginStatusProvider: PluginStatusProvider

resolvedPlugins

protected var resolvedPlugins: MutableList<PluginWrapper>

runtimeMode

protected var runtimeMode: RuntimeMode

startedPlugins

protected var startedPlugins: MutableList<PluginWrapper>

systemVersion

protected var systemVersion: String

unresolvedPlugins

protected var unresolvedPlugins: MutableList<PluginWrapper>

versionManager

protected var versionManager: VersionManager

Functions

addPluginStateListener

open override fun addPluginStateListener(p0: PluginStateListener)

addTabExtensionTabs

fun addTabExtensionTabs(tabbedPane: JTabbedPane)

Add any and all additional tabs to the ServerPackCreator tabbed pane (main GUI). You may use this to add tabs to your own JTabbedPane, if you so desire. Could be pretty awesome to have your plugins extra tabs in a separate window!

checkPluginId

protected open fun checkPluginId(p0: String)

createExtensionFactory

protected open override fun createExtensionFactory(): ExtensionFactory

createExtensionFinder

protected open override fun createExtensionFinder(): ExtensionFinder

createPluginDescriptorFinder

protected open override fun createPluginDescriptorFinder(): PluginDescriptorFinder

createPluginFactory

protected open override fun createPluginFactory(): PluginFactory

createPluginLoader

protected open override fun createPluginLoader(): PluginLoader

createPluginRepository

protected open override fun createPluginRepository(): PluginRepository

createPluginsRoot

protected open fun createPluginsRoot(): MutableList<Path>

createPluginStatusProvider

protected open override fun createPluginStatusProvider(): PluginStatusProvider

createPluginWrapper

protected open fun createPluginWrapper(p0: PluginDescriptor, p1: Path, p2: ClassLoader): PluginWrapper

createVersionManager

protected open override fun createVersionManager(): VersionManager

deletePlugin

open override fun deletePlugin(p0: String): Boolean

disablePlugin

open override fun disablePlugin(p0: String): Boolean

enablePlugin

open override fun enablePlugin(p0: String): Boolean

firePluginStateEvent

protected open fun firePluginStateEvent(p0: PluginStateEvent)

getAllExtensionsOfPlugin

fun <T> getAllExtensionsOfPlugin(plugin: PluginWrapper, type: Class<T>): List<T>

Get all extension of the specified type for the specified plugin.

getConfigPanels

fun getConfigPanels(serverPackConfigTab: ServerPackConfigTab): List<ExtensionConfigPanel>

Create config panels for the passed server pack configuration tab. Note that this method does NOT add the panels to the tab, it only creates them and passes the server pack config tab object-reference to each config panel, so they, in turn, may use any available fields and methods for their own operations. A given server pack config tab needs to add the panels which are returned by this method, so a user may make their configurations accordingly.

getExtensionClasses

open override fun <T : Any> getExtensionClasses(p0: Class<T>): MutableList<Class<out T>>

open override fun getExtensionClasses(p0: String): MutableList<Class<*>>

protected open fun <T : Any> getExtensionClasses(p0: MutableList<ExtensionWrapper<T>>): MutableList<Class<out T>>

open override fun <T : Any> getExtensionClasses(p0: Class<T>, p1: String): MutableList<Class<out T>>

getExtensionClassNames

open override fun getExtensionClassNames(p0: String): MutableSet<String>

getExtensionFactory

open override fun getExtensionFactory(): ExtensionFactory

getExtensions

open override fun <T : Any> getExtensions(p0: Class<T>): MutableList<T>

open override fun getExtensions(p0: String): MutableList<Any?>

protected open fun <T : Any> getExtensions(p0: MutableList<ExtensionWrapper<T>>): MutableList<T>

open override fun <T : Any> getExtensions(p0: Class<T>, p1: String): MutableList<T>

getPlugin

open override fun getPlugin(p0: String): PluginWrapper

getPluginClassLoader

open override fun getPluginClassLoader(p0: String): ClassLoader

getPluginClassLoaders

protected open fun getPluginClassLoaders(): MutableMap<String, ClassLoader>

getPluginConfig

expect fun getPluginConfig(pluginId: String): Optional<CommentedConfig>

Get the global plugin configuration for a plugin of the passed ID. The configuration is wrapped in an Optional, because a plugin may not provide a global configuration. If you intend on using a global configuration for your plugin, make sure to check whether it is present before trying to use it!

actual fun getPluginConfig(pluginId: String): Optional<CommentedConfig>

Get the global plugin configuration for an plugin of the passed ID. The configuration is wrapped in an Optional, because an plugin may not provide a global configuration. If you intend on using a global configuration for your plugin, make sure to check whether it is present before trying to use it!

getPluginConfigFile

expect fun getPluginConfigFile(pluginId: String): Optional<File>

Get the configuration-file for a plugin, if it exists. This is wrapped in an Optional, because not every plugin may provide a configuration-file to use globally for the relevant plugins settings. If you intend on using a global configuration, make sure to check whether the file is present, before moving on!

actual fun getPluginConfigFile(pluginId: String): Optional<File>

getPluginDescriptorFinder

protected open fun getPluginDescriptorFinder(): PluginDescriptorFinder

getPluginFactory

protected open fun getPluginFactory(): PluginFactory

getPluginLabel

protected open fun getPluginLabel(p0: PluginDescriptor): String

getPluginLoader

open fun getPluginLoader(): PluginLoader

getPlugins

open override fun getPlugins(): MutableList<PluginWrapper>

open override fun getPlugins(p0: PluginState): MutableList<PluginWrapper>

getPluginsRoot

open override fun getPluginsRoot(): Path

getPluginsRoots

open override fun getPluginsRoots(): MutableList<Path>

getResolvedPlugins

open override fun getResolvedPlugins(): MutableList<PluginWrapper>

getRuntimeMode

open override fun getRuntimeMode(): RuntimeMode

getStartedPlugins

open override fun getStartedPlugins(): MutableList<PluginWrapper>

getSystemVersion

open override fun getSystemVersion(): String

getUnresolvedPlugins

open override fun getUnresolvedPlugins(): MutableList<PluginWrapper>

getVersion

open fun getVersion(): String

getVersionManager

open override fun getVersionManager(): VersionManager

idForPath

protected open fun idForPath(p0: Path): String

initialize

protected open override fun initialize()

isDevelopment

open fun isDevelopment(): Boolean

isExactVersionAllowed

open fun isExactVersionAllowed(): Boolean

isNotDevelopment

open fun isNotDevelopment(): Boolean

isPluginDisabled

protected open fun isPluginDisabled(p0: String): Boolean

isPluginValid

protected open fun isPluginValid(p0: PluginWrapper): Boolean

loadPlugin

open override fun loadPlugin(p0: Path): String

loadPluginFromPath

protected open override fun loadPluginFromPath(p0: Path): PluginWrapper

loadPlugins

open override fun loadPlugins()

removePluginStateListener

open override fun removePluginStateListener(p0: PluginStateListener)

resolvePlugins

protected open fun resolvePlugins()

runConfigCheckExtensions

expect fun runConfigCheckExtensions(packConfig: PackConfig, configCheck: ConfigCheck = ConfigCheck()): ConfigCheck

Run any and all configuration-check extensions, using the passed configuration model and the destination at which the server pack is to be generated and stored at.

actual fun runConfigCheckExtensions(packConfig: PackConfig, configCheck: ConfigCheck): ConfigCheck

Run any and all configuration-check extensions, using the passed configuration model and the destination at which the server pack is to be generated and stored at.

runPostGenExtensions

expect fun runPostGenExtensions(packConfig: PackConfig, destination: String)

Run any and all Post-server pack-generation extensions, using the passed configuration model and the destination at which the server pack is to be generated and stored at.

actual fun runPostGenExtensions(packConfig: PackConfig, destination: String)

Run any and all Post-server pack-generation extensions, using the passed configuration model and the destination at which the server pack is to be generated and stored at.

runPreGenExtensions

expect fun runPreGenExtensions(packConfig: PackConfig, destination: String)

Run any and all Pre-Server Pack-Generation extensions, using the passed configuration model and the destination at which the server pack is to be generated and stored at.

actual fun runPreGenExtensions(packConfig: PackConfig, destination: String)

Run any and all Pre-Server Pack-Generation extensions, using the passed configuration model and the destination at which the server pack is to be generated and stored at.

runPreZipExtensions

expect fun runPreZipExtensions(packConfig: PackConfig, destination: String)

Run any and all Pre-ZIP-archive creation extensions, using the passed configuration model and the destination at which the server pack is to be generated and stored at.

actual fun runPreZipExtensions(packConfig: PackConfig, destination: String)

Run any and all Pre-ZIP-archive creation extensions, using the passed configuration model and the destination at which the server pack is to be generated and stored at.

setExactVersionAllowed