Preinitialized log4j PluginManager for Spigot

Spigot/SteamWar-Patches/Preinitialized_log4j_PluginManager.patch

@@ -0,0 +1,275 @@
+Index: src/main/java/org/apache/logging/log4j/core/config/plugins/util/PluginManager.java
+IDEA additional info:
+Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
+<+>UTF-8
+===================================================================
+diff --git a/src/main/java/org/apache/logging/log4j/core/config/plugins/util/PluginManager.java b/src/main/java/org/apache/logging/log4j/core/config/plugins/util/PluginManager.java
+new file mode 100644
+--- /dev/null	(date 1631868563744)
++++ b/src/main/java/org/apache/logging/log4j/core/config/plugins/util/PluginManager.java	(date 1631868563744)
+@@ -0,0 +1,265 @@
++package org.apache.logging.log4j.core.config.plugins.util;
++
++import java.util.*;
++
++import org.apache.logging.log4j.core.config.plugins.processor.PluginEntry;
++
++public class PluginManager {
++    private Map<String, PluginType<?>> plugins = new HashMap<>();
++    private final String category;
++
++    public PluginManager(String category) {
++        this.category = category;
++    }
++
++    public static void addPackage(String p) {
++        //unused
++    }
++
++    public static void addPackages(Collection<String> packages) {
++        //unused
++    }
++
++    public PluginType<?> getPluginType(String name) {
++        return this.plugins.get(name.toLowerCase());
++    }
++
++    public Map<String, PluginType<?>> getPlugins() {
++        return this.plugins;
++    }
++
++    public void collectPlugins() {
++        this.collectPlugins(null);
++    }
++
++    private PluginEntry entryCreator(String key, String className, String name, boolean printable, boolean defer, String category) {
++        PluginEntry entry = new PluginEntry();
++        entry.setKey(key);
++        entry.setClassName(className);
++        entry.setName(name);
++        entry.setPrintable(printable);
++        entry.setDefer(defer);
++        entry.setCategory(category);
++        return entry;
++    }
++
++    public void collectPlugins(List<String> packages) {
++        Map<String, PluginType<?>> map = new LinkedHashMap<>();
++
++        switch(category) {
++            case "ConfigurationFactory":
++                map.put("jsonconfigurationfactory", new PluginType<>(entryCreator("jsonconfigurationfactory", "org.apache.logging.log4j.core.config.json.JsonConfigurationFactory", "JsonConfigurationFactory", false, false, "ConfigurationFactory"), org.apache.logging.log4j.core.config.json.JsonConfigurationFactory.class, "JsonConfigurationFactory"));
++                map.put("propertiesconfigurationfactory", new PluginType<>(entryCreator("propertiesconfigurationfactory", "org.apache.logging.log4j.core.config.properties.PropertiesConfigurationFactory", "PropertiesConfigurationFactory", false, false, "ConfigurationFactory"), org.apache.logging.log4j.core.config.properties.PropertiesConfigurationFactory.class, "PropertiesConfigurationFactory"));
++                map.put("xmlconfigurationfactory", new PluginType<>(entryCreator("xmlconfigurationfactory", "org.apache.logging.log4j.core.config.xml.XmlConfigurationFactory", "XmlConfigurationFactory", false, false, "ConfigurationFactory"), org.apache.logging.log4j.core.config.xml.XmlConfigurationFactory.class, "XmlConfigurationFactory"));
++                map.put("yamlconfigurationfactory", new PluginType<>(entryCreator("yamlconfigurationfactory", "org.apache.logging.log4j.core.config.yaml.YamlConfigurationFactory", "YamlConfigurationFactory", false, false, "ConfigurationFactory"), org.apache.logging.log4j.core.config.yaml.YamlConfigurationFactory.class, "YamlConfigurationFactory"));
++                break;
++            case "Converter":
++                map.put("black", new PluginType<>(entryCreator("black", "org.apache.logging.log4j.core.pattern.AbstractStyleNameConverter$Black", "black", false, false, "Converter"), org.apache.logging.log4j.core.pattern.AbstractStyleNameConverter.Black.class, "black"));
++                map.put("blue", new PluginType<>(entryCreator("blue", "org.apache.logging.log4j.core.pattern.AbstractStyleNameConverter$Blue", "blue", false, false, "Converter"), org.apache.logging.log4j.core.pattern.AbstractStyleNameConverter.Blue.class, "blue"));
++                map.put("classnamepatternconverter", new PluginType<>(entryCreator("classnamepatternconverter", "org.apache.logging.log4j.core.pattern.ClassNamePatternConverter", "ClassNamePatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.ClassNamePatternConverter.class, "ClassNamePatternConverter"));
++                map.put("cyan", new PluginType<>(entryCreator("cyan", "org.apache.logging.log4j.core.pattern.AbstractStyleNameConverter$Cyan", "cyan", false, false, "Converter"), org.apache.logging.log4j.core.pattern.AbstractStyleNameConverter.Cyan.class, "cyan"));
++                map.put("datepatternconverter", new PluginType<>(entryCreator("datepatternconverter", "org.apache.logging.log4j.core.pattern.DatePatternConverter", "DatePatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.DatePatternConverter.class, "DatePatternConverter"));
++                map.put("encode", new PluginType<>(entryCreator("encode", "org.apache.logging.log4j.core.pattern.EncodingPatternConverter", "encode", false, false, "Converter"), org.apache.logging.log4j.core.pattern.EncodingPatternConverter.class, "encode"));
++                map.put("equalsignorecase", new PluginType<>(entryCreator("equalsignorecase", "org.apache.logging.log4j.core.pattern.EqualsIgnoreCaseReplacementConverter", "equalsIgnoreCase", false, false, "Converter"), org.apache.logging.log4j.core.pattern.EqualsIgnoreCaseReplacementConverter.class, "equalsIgnoreCase"));
++                map.put("equals", new PluginType<>(entryCreator("equals", "org.apache.logging.log4j.core.pattern.EqualsReplacementConverter", "equals", false, false, "Converter"), org.apache.logging.log4j.core.pattern.EqualsReplacementConverter.class, "equals"));
++                map.put("extendedthrowablepatternconverter", new PluginType<>(entryCreator("extendedthrowablepatternconverter", "org.apache.logging.log4j.core.pattern.ExtendedThrowablePatternConverter", "ExtendedThrowablePatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.ExtendedThrowablePatternConverter.class, "ExtendedThrowablePatternConverter"));
++                map.put("filelocationpatternconverter", new PluginType<>(entryCreator("filelocationpatternconverter", "org.apache.logging.log4j.core.pattern.FileLocationPatternConverter", "FileLocationPatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.FileLocationPatternConverter.class, "FileLocationPatternConverter"));
++                map.put("fulllocationpatternconverter", new PluginType<>(entryCreator("fulllocationpatternconverter", "org.apache.logging.log4j.core.pattern.FullLocationPatternConverter", "FullLocationPatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.FullLocationPatternConverter.class, "FullLocationPatternConverter"));
++                map.put("green", new PluginType<>(entryCreator("green", "org.apache.logging.log4j.core.pattern.AbstractStyleNameConverter$Green", "green", false, false, "Converter"), org.apache.logging.log4j.core.pattern.AbstractStyleNameConverter.Green.class, "green"));
++                map.put("highlight", new PluginType<>(entryCreator("highlight", "org.apache.logging.log4j.core.pattern.HighlightConverter", "highlight", false, false, "Converter"), org.apache.logging.log4j.core.pattern.HighlightConverter.class, "highlight"));
++                map.put("levelpatternconverter", new PluginType<>(entryCreator("levelpatternconverter", "org.apache.logging.log4j.core.pattern.LevelPatternConverter", "LevelPatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.LevelPatternConverter.class, "LevelPatternConverter"));
++                map.put("linelocationpatternconverter", new PluginType<>(entryCreator("linelocationpatternconverter", "org.apache.logging.log4j.core.pattern.LineLocationPatternConverter", "LineLocationPatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.LineLocationPatternConverter.class, "LineLocationPatternConverter"));
++                map.put("lineseparatorpatternconverter", new PluginType<>(entryCreator("lineseparatorpatternconverter", "org.apache.logging.log4j.core.pattern.LineSeparatorPatternConverter", "LineSeparatorPatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.LineSeparatorPatternConverter.class, "LineSeparatorPatternConverter"));
++                map.put("loggerpatternconverter", new PluginType<>(entryCreator("loggerpatternconverter", "org.apache.logging.log4j.core.pattern.LoggerPatternConverter", "LoggerPatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.LoggerPatternConverter.class, "LoggerPatternConverter"));
++                map.put("magenta", new PluginType<>(entryCreator("magenta", "org.apache.logging.log4j.core.pattern.AbstractStyleNameConverter$Magenta", "magenta", false, false, "Converter"), org.apache.logging.log4j.core.pattern.AbstractStyleNameConverter.Magenta.class, "magenta"));
++                map.put("mappatternconverter", new PluginType<>(entryCreator("mappatternconverter", "org.apache.logging.log4j.core.pattern.MapPatternConverter", "MapPatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.MapPatternConverter.class, "MapPatternConverter"));
++                map.put("markernamepatternconverter", new PluginType<>(entryCreator("markernamepatternconverter", "org.apache.logging.log4j.core.pattern.MarkerSimpleNamePatternConverter", "MarkerNamePatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.MarkerSimpleNamePatternConverter.class, "MarkerNamePatternConverter"));
++                map.put("markerpatternconverter", new PluginType<>(entryCreator("markerpatternconverter", "org.apache.logging.log4j.core.pattern.MarkerPatternConverter", "MarkerPatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.MarkerPatternConverter.class, "MarkerPatternConverter"));
++                map.put("maxlength", new PluginType<>(entryCreator("maxlength", "org.apache.logging.log4j.core.pattern.MaxLengthConverter", "maxLength", false, false, "Converter"), org.apache.logging.log4j.core.pattern.MaxLengthConverter.class, "maxLength"));
++                map.put("mdcpatternconverter", new PluginType<>(entryCreator("mdcpatternconverter", "org.apache.logging.log4j.core.pattern.MdcPatternConverter", "MdcPatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.MdcPatternConverter.class, "MdcPatternConverter"));
++                map.put("messagepatternconverter", new PluginType<>(entryCreator("messagepatternconverter", "org.apache.logging.log4j.core.pattern.MessagePatternConverter", "MessagePatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.MessagePatternConverter.class, "MessagePatternConverter"));
++                map.put("methodlocationpatternconverter", new PluginType<>(entryCreator("methodlocationpatternconverter", "org.apache.logging.log4j.core.pattern.MethodLocationPatternConverter", "MethodLocationPatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.MethodLocationPatternConverter.class, "MethodLocationPatternConverter"));
++                map.put("nanotimepatternconverter", new PluginType<>(entryCreator("nanotimepatternconverter", "org.apache.logging.log4j.core.pattern.NanoTimePatternConverter", "NanoTimePatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.NanoTimePatternConverter.class, "NanoTimePatternConverter"));
++                map.put("ndcpatternconverter", new PluginType<>(entryCreator("ndcpatternconverter", "org.apache.logging.log4j.core.pattern.NdcPatternConverter", "NdcPatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.NdcPatternConverter.class, "NdcPatternConverter"));
++                map.put("notempty", new PluginType<>(entryCreator("notempty", "org.apache.logging.log4j.core.pattern.VariablesNotEmptyReplacementConverter", "notEmpty", false, false, "Converter"), org.apache.logging.log4j.core.pattern.VariablesNotEmptyReplacementConverter.class, "notEmpty"));
++                map.put("red", new PluginType<>(entryCreator("red", "org.apache.logging.log4j.core.pattern.AbstractStyleNameConverter$Red", "red", false, false, "Converter"), org.apache.logging.log4j.core.pattern.AbstractStyleNameConverter.Red.class, "red"));
++                map.put("relativetimepatternconverter", new PluginType<>(entryCreator("relativetimepatternconverter", "org.apache.logging.log4j.core.pattern.RelativeTimePatternConverter", "RelativeTimePatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.RelativeTimePatternConverter.class, "RelativeTimePatternConverter"));
++                map.put("replace", new PluginType<>(entryCreator("replace", "org.apache.logging.log4j.core.pattern.RegexReplacementConverter", "replace", false, false, "Converter"), org.apache.logging.log4j.core.pattern.RegexReplacementConverter.class, "replace"));
++                map.put("rootthrowablepatternconverter", new PluginType<>(entryCreator("rootthrowablepatternconverter", "org.apache.logging.log4j.core.pattern.RootThrowablePatternConverter", "RootThrowablePatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.RootThrowablePatternConverter.class, "RootThrowablePatternConverter"));
++                map.put("sequencenumberpatternconverter", new PluginType<>(entryCreator("sequencenumberpatternconverter", "org.apache.logging.log4j.core.pattern.SequenceNumberPatternConverter", "SequenceNumberPatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.SequenceNumberPatternConverter.class, "SequenceNumberPatternConverter"));
++                map.put("style", new PluginType<>(entryCreator("style", "org.apache.logging.log4j.core.pattern.StyleConverter", "style", false, false, "Converter"), org.apache.logging.log4j.core.pattern.StyleConverter.class, "style"));
++                map.put("threadidpatternconverter", new PluginType<>(entryCreator("threadidpatternconverter", "org.apache.logging.log4j.core.pattern.ThreadIdPatternConverter", "ThreadIdPatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.ThreadIdPatternConverter.class, "ThreadIdPatternConverter"));
++                map.put("threadpatternconverter", new PluginType<>(entryCreator("threadpatternconverter", "org.apache.logging.log4j.core.pattern.ThreadNamePatternConverter", "ThreadPatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.ThreadNamePatternConverter.class, "ThreadPatternConverter"));
++                map.put("threadprioritypatternconverter", new PluginType<>(entryCreator("threadprioritypatternconverter", "org.apache.logging.log4j.core.pattern.ThreadPriorityPatternConverter", "ThreadPriorityPatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.ThreadPriorityPatternConverter.class, "ThreadPriorityPatternConverter"));
++                map.put("throwablepatternconverter", new PluginType<>(entryCreator("throwablepatternconverter", "org.apache.logging.log4j.core.pattern.ThrowablePatternConverter", "ThrowablePatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.ThrowablePatternConverter.class, "ThrowablePatternConverter"));
++                map.put("uuidpatternconverter", new PluginType<>(entryCreator("uuidpatternconverter", "org.apache.logging.log4j.core.pattern.UuidPatternConverter", "UuidPatternConverter", false, false, "Converter"), org.apache.logging.log4j.core.pattern.UuidPatternConverter.class, "UuidPatternConverter"));
++                map.put("white", new PluginType<>(entryCreator("white", "org.apache.logging.log4j.core.pattern.AbstractStyleNameConverter$White", "white", false, false, "Converter"), org.apache.logging.log4j.core.pattern.AbstractStyleNameConverter.White.class, "white"));
++                map.put("yellow", new PluginType<>(entryCreator("yellow", "org.apache.logging.log4j.core.pattern.AbstractStyleNameConverter$Yellow", "yellow", false, false, "Converter"), org.apache.logging.log4j.core.pattern.AbstractStyleNameConverter.Yellow.class, "yellow"));
++                break;
++            case "Core":
++                map.put("appender-ref", new PluginType<>(entryCreator("appender-ref", "org.apache.logging.log4j.core.config.AppenderRef", "AppenderRef", true, false, "Core"), org.apache.logging.log4j.core.config.AppenderRef.class, "AppenderRef"));
++                map.put("appenderref", new PluginType<>(entryCreator("appenderref", "org.apache.logging.log4j.core.config.AppenderRef", "AppenderRef", true, false, "Core"), org.apache.logging.log4j.core.config.AppenderRef.class, "AppenderRef"));
++                map.put("appenderset", new PluginType<>(entryCreator("appenderset", "org.apache.logging.log4j.core.appender.AppenderSet", "AppenderSet", true, true, "Core"), org.apache.logging.log4j.core.appender.AppenderSet.class, "AppenderSet"));
++                map.put("appenders", new PluginType<>(entryCreator("appenders", "org.apache.logging.log4j.core.config.AppendersPlugin", "appenders", false, false, "Core"), org.apache.logging.log4j.core.config.AppendersPlugin.class, "appenders"));
++                map.put("arrayblockingqueue", new PluginType<>(entryCreator("arrayblockingqueue", "org.apache.logging.log4j.core.async.ArrayBlockingQueueFactory", "ArrayBlockingQueue", false, false, "Core"), org.apache.logging.log4j.core.async.ArrayBlockingQueueFactory.class, "ArrayBlockingQueue"));
++                map.put("asynclogger", new PluginType<>(entryCreator("asynclogger", "org.apache.logging.log4j.core.async.AsyncLoggerConfig", "asyncLogger", true, false, "Core"), org.apache.logging.log4j.core.async.AsyncLoggerConfig.class, "asyncLogger"));
++                map.put("async", new PluginType<>(entryCreator("async", "org.apache.logging.log4j.core.appender.AsyncAppender", "Async", true, false, "Core"), org.apache.logging.log4j.core.appender.AsyncAppender.class, "Async"));
++                map.put("asyncroot", new PluginType<>(entryCreator("asyncroot", "org.apache.logging.log4j.core.async.AsyncLoggerConfig$RootLogger", "asyncRoot", true, false, "Core"), org.apache.logging.log4j.core.async.AsyncLoggerConfig.RootLogger.class, "asyncRoot"));
++                map.put("burstfilter", new PluginType<>(entryCreator("burstfilter", "org.apache.logging.log4j.core.filter.BurstFilter", "BurstFilter", true, false, "Core"), org.apache.logging.log4j.core.filter.BurstFilter.class, "BurstFilter"));
++                map.put("columnmapping", new PluginType<>(entryCreator("columnmapping", "org.apache.logging.log4j.core.appender.db.ColumnMapping", "ColumnMapping", true, false, "Core"), org.apache.logging.log4j.core.appender.db.ColumnMapping.class, "ColumnMapping"));
++                map.put("column", new PluginType<>(entryCreator("column", "org.apache.logging.log4j.core.appender.db.jdbc.ColumnConfig", "Column", true, false, "Core"), org.apache.logging.log4j.core.appender.db.jdbc.ColumnConfig.class, "Column"));
++                map.put("connectionfactory", new PluginType<>(entryCreator("connectionfactory", "org.apache.logging.log4j.core.appender.db.jdbc.FactoryMethodConnectionSource", "ConnectionFactory", true, false, "Core"), org.apache.logging.log4j.core.appender.db.jdbc.FactoryMethodConnectionSource.class, "ConnectionFactory"));
++                map.put("console", new PluginType<>(entryCreator("console", "org.apache.logging.log4j.core.appender.ConsoleAppender", "Console", true, false, "Core"), org.apache.logging.log4j.core.appender.ConsoleAppender.class, "Console"));
++                map.put("contextmapfilter", new PluginType<>(entryCreator("contextmapfilter", "org.apache.logging.log4j.core.filter.ThreadContextMapFilter", "ThreadContextMapFilter", true, false, "Core"), org.apache.logging.log4j.core.filter.ThreadContextMapFilter.class, "ThreadContextMapFilter"));
++                map.put("countingnoop", new PluginType<>(entryCreator("countingnoop", "org.apache.logging.log4j.core.appender.CountingNoOpAppender", "CountingNoOp", true, false, "Core"), org.apache.logging.log4j.core.appender.CountingNoOpAppender.class, "CountingNoOp"));
++                map.put("crontriggeringpolicy", new PluginType<>(entryCreator("crontriggeringpolicy", "org.apache.logging.log4j.core.appender.rolling.CronTriggeringPolicy", "CronTriggeringPolicy", true, false, "Core"), org.apache.logging.log4j.core.appender.rolling.CronTriggeringPolicy.class, "CronTriggeringPolicy"));
++                map.put("csvlogeventlayout", new PluginType<>(entryCreator("csvlogeventlayout", "org.apache.logging.log4j.core.layout.CsvLogEventLayout", "CsvLogEventLayout", true, false, "Core"), org.apache.logging.log4j.core.layout.CsvLogEventLayout.class, "CsvLogEventLayout"));
++                map.put("csvparameterlayout", new PluginType<>(entryCreator("csvparameterlayout", "org.apache.logging.log4j.core.layout.CsvParameterLayout", "CsvParameterLayout", true, false, "Core"), org.apache.logging.log4j.core.layout.CsvParameterLayout.class, "CsvParameterLayout"));
++                map.put("customlevel", new PluginType<>(entryCreator("customlevel", "org.apache.logging.log4j.core.config.CustomLevelConfig", "CustomLevel", true, false, "Core"), org.apache.logging.log4j.core.config.CustomLevelConfig.class, "CustomLevel"));
++                map.put("customlevels", new PluginType<>(entryCreator("customlevels", "org.apache.logging.log4j.core.config.CustomLevels", "CustomLevels", true, false, "Core"), org.apache.logging.log4j.core.config.CustomLevels.class, "CustomLevels"));
++                map.put("datasource", new PluginType<>(entryCreator("datasource", "org.apache.logging.log4j.core.appender.db.jdbc.DataSourceConnectionSource", "DataSource", true, false, "Core"), org.apache.logging.log4j.core.appender.db.jdbc.DataSourceConnectionSource.class, "DataSource"));
++                map.put("default", new PluginType<>(entryCreator("default", "org.apache.logging.log4j.core.config.DefaultAdvertiser", "default", false, false, "Core"), org.apache.logging.log4j.core.config.DefaultAdvertiser.class, "default"));
++                map.put("defaultrolloverstrategy", new PluginType<>(entryCreator("defaultrolloverstrategy", "org.apache.logging.log4j.core.appender.rolling.DefaultRolloverStrategy", "DefaultRolloverStrategy", true, false, "Core"), org.apache.logging.log4j.core.appender.rolling.DefaultRolloverStrategy.class, "DefaultRolloverStrategy"));
++                map.put("delete", new PluginType<>(entryCreator("delete", "org.apache.logging.log4j.core.appender.rolling.action.DeleteAction", "Delete", true, false, "Core"), org.apache.logging.log4j.core.appender.rolling.action.DeleteAction.class, "Delete"));
++                map.put("directwriterolloverstrategy", new PluginType<>(entryCreator("directwriterolloverstrategy", "org.apache.logging.log4j.core.appender.rolling.DirectWriteRolloverStrategy", "DirectWriteRolloverStrategy", true, false, "Core"), org.apache.logging.log4j.core.appender.rolling.DirectWriteRolloverStrategy.class, "DirectWriteRolloverStrategy"));
++                map.put("disruptorblockingqueue", new PluginType<>(entryCreator("disruptorblockingqueue", "org.apache.logging.log4j.core.async.DisruptorBlockingQueueFactory", "DisruptorBlockingQueue", false, false, "Core"), org.apache.logging.log4j.core.async.DisruptorBlockingQueueFactory.class, "DisruptorBlockingQueue"));
++                map.put("dynamicthresholdfilter", new PluginType<>(entryCreator("dynamicthresholdfilter", "org.apache.logging.log4j.core.filter.DynamicThresholdFilter", "DynamicThresholdFilter", true, false, "Core"), org.apache.logging.log4j.core.filter.DynamicThresholdFilter.class, "DynamicThresholdFilter"));
++                map.put("failover", new PluginType<>(entryCreator("failover", "org.apache.logging.log4j.core.appender.FailoverAppender", "Failover", true, false, "Core"), org.apache.logging.log4j.core.appender.FailoverAppender.class, "Failover"));
++                map.put("failovers", new PluginType<>(entryCreator("failovers", "org.apache.logging.log4j.core.appender.FailoversPlugin", "failovers", false, false, "Core"), org.apache.logging.log4j.core.appender.FailoversPlugin.class, "failovers"));
++                map.put("file", new PluginType<>(entryCreator("file", "org.apache.logging.log4j.core.appender.FileAppender", "File", true, false, "Core"), org.apache.logging.log4j.core.appender.FileAppender.class, "File"));
++                map.put("filters", new PluginType<>(entryCreator("filters", "org.apache.logging.log4j.core.filter.CompositeFilter", "filters", true, false, "Core"), org.apache.logging.log4j.core.filter.CompositeFilter.class, "filters"));
++                map.put("gelflayout", new PluginType<>(entryCreator("gelflayout", "org.apache.logging.log4j.core.layout.GelfLayout", "GelfLayout", true, false, "Core"), org.apache.logging.log4j.core.layout.GelfLayout.class, "GelfLayout"));
++                map.put("htmllayout", new PluginType<>(entryCreator("htmllayout", "org.apache.logging.log4j.core.layout.HtmlLayout", "HtmlLayout", true, false, "Core"), org.apache.logging.log4j.core.layout.HtmlLayout.class, "HtmlLayout"));
++                map.put("idlepurgepolicy", new PluginType<>(entryCreator("idlepurgepolicy", "org.apache.logging.log4j.core.appender.routing.IdlePurgePolicy", "IdlePurgePolicy", true, false, "Core"), org.apache.logging.log4j.core.appender.routing.IdlePurgePolicy.class, "IdlePurgePolicy"));
++                map.put("ifaccumulatedfilecount", new PluginType<>(entryCreator("ifaccumulatedfilecount", "org.apache.logging.log4j.core.appender.rolling.action.IfAccumulatedFileCount", "IfAccumulatedFileCount", true, false, "Core"), org.apache.logging.log4j.core.appender.rolling.action.IfAccumulatedFileCount.class, "IfAccumulatedFileCount"));
++                map.put("ifaccumulatedfilesize", new PluginType<>(entryCreator("ifaccumulatedfilesize", "org.apache.logging.log4j.core.appender.rolling.action.IfAccumulatedFileSize", "IfAccumulatedFileSize", true, false, "Core"), org.apache.logging.log4j.core.appender.rolling.action.IfAccumulatedFileSize.class, "IfAccumulatedFileSize"));
++                map.put("ifall", new PluginType<>(entryCreator("ifall", "org.apache.logging.log4j.core.appender.rolling.action.IfAll", "IfAll", true, false, "Core"), org.apache.logging.log4j.core.appender.rolling.action.IfAll.class, "IfAll"));
++                map.put("ifany", new PluginType<>(entryCreator("ifany", "org.apache.logging.log4j.core.appender.rolling.action.IfAny", "IfAny", true, false, "Core"), org.apache.logging.log4j.core.appender.rolling.action.IfAny.class, "IfAny"));
++                map.put("iffilename", new PluginType<>(entryCreator("iffilename", "org.apache.logging.log4j.core.appender.rolling.action.IfFileName", "IfFileName", true, false, "Core"), org.apache.logging.log4j.core.appender.rolling.action.IfFileName.class, "IfFileName"));
++                map.put("iflastmodified", new PluginType<>(entryCreator("iflastmodified", "org.apache.logging.log4j.core.appender.rolling.action.IfLastModified", "IfLastModified", true, false, "Core"), org.apache.logging.log4j.core.appender.rolling.action.IfLastModified.class, "IfLastModified"));
++                map.put("ifnot", new PluginType<>(entryCreator("ifnot", "org.apache.logging.log4j.core.appender.rolling.action.IfNot", "IfNot", true, false, "Core"), org.apache.logging.log4j.core.appender.rolling.action.IfNot.class, "IfNot"));
++                map.put("jctoolsblockingqueue", new PluginType<>(entryCreator("jctoolsblockingqueue", "org.apache.logging.log4j.core.async.JCToolsBlockingQueueFactory", "JCToolsBlockingQueue", false, false, "Core"), org.apache.logging.log4j.core.async.JCToolsBlockingQueueFactory.class, "JCToolsBlockingQueue"));
++                map.put("jdbc", new PluginType<>(entryCreator("jdbc", "org.apache.logging.log4j.core.appender.db.jdbc.JdbcAppender", "JDBC", true, false, "Core"), org.apache.logging.log4j.core.appender.db.jdbc.JdbcAppender.class, "JDBC"));
++                map.put("jeromq", new PluginType<>(entryCreator("jeromq", "org.apache.logging.log4j.core.appender.mom.jeromq.JeroMqAppender", "JeroMQ", true, false, "Core"), org.apache.logging.log4j.core.appender.mom.jeromq.JeroMqAppender.class, "JeroMQ"));
++                map.put("jms", new PluginType<>(entryCreator("jms", "org.apache.logging.log4j.core.appender.mom.JmsAppender", "JMS", true, false, "Core"), org.apache.logging.log4j.core.appender.mom.JmsAppender.class, "JMS"));
++                map.put("jmsqueue", new PluginType<>(entryCreator("jmsqueue", "org.apache.logging.log4j.core.appender.mom.JmsAppender", "JMS", true, false, "Core"), org.apache.logging.log4j.core.appender.mom.JmsAppender.class, "JMS"));
++                map.put("jmstopic", new PluginType<>(entryCreator("jmstopic", "org.apache.logging.log4j.core.appender.mom.JmsAppender", "JMS", true, false, "Core"), org.apache.logging.log4j.core.appender.mom.JmsAppender.class, "JMS"));
++                map.put("jpa", new PluginType<>(entryCreator("jpa", "org.apache.logging.log4j.core.appender.db.jpa.JpaAppender", "JPA", true, false, "Core"), org.apache.logging.log4j.core.appender.db.jpa.JpaAppender.class, "JPA"));
++                map.put("jsonlayout", new PluginType<>(entryCreator("jsonlayout", "org.apache.logging.log4j.core.layout.JsonLayout", "JsonLayout", true, false, "Core"), org.apache.logging.log4j.core.layout.JsonLayout.class, "JsonLayout"));
++                map.put("kafka", new PluginType<>(entryCreator("kafka", "org.apache.logging.log4j.core.appender.mom.kafka.KafkaAppender", "Kafka", true, false, "Core"), org.apache.logging.log4j.core.appender.mom.kafka.KafkaAppender.class, "Kafka"));
++                map.put("keystore", new PluginType<>(entryCreator("keystore", "org.apache.logging.log4j.core.net.ssl.KeyStoreConfiguration", "KeyStore", true, false, "Core"), org.apache.logging.log4j.core.net.ssl.KeyStoreConfiguration.class, "KeyStore"));
++                map.put("keyvaluepair", new PluginType<>(entryCreator("keyvaluepair", "org.apache.logging.log4j.core.util.KeyValuePair", "KeyValuePair", true, false, "Core"), org.apache.logging.log4j.core.util.KeyValuePair.class, "KeyValuePair"));
++                map.put("levelrangefilter", new PluginType<>(entryCreator("levelrangefilter", "org.apache.logging.log4j.core.filter.LevelRangeFilter", "LevelRangeFilter", true, false, "Core"), org.apache.logging.log4j.core.filter.LevelRangeFilter.class, "LevelRangeFilter"));
++                map.put("linkedtransferqueue", new PluginType<>(entryCreator("linkedtransferqueue", "org.apache.logging.log4j.core.async.LinkedTransferQueueFactory", "LinkedTransferQueue", false, false, "Core"), org.apache.logging.log4j.core.async.LinkedTransferQueueFactory.class, "LinkedTransferQueue"));
++                map.put("loggerfields", new PluginType<>(entryCreator("loggerfields", "org.apache.logging.log4j.core.layout.LoggerFields", "LoggerFields", true, false, "Core"), org.apache.logging.log4j.core.layout.LoggerFields.class, "LoggerFields"));
++                map.put("loggernamelevelrewritepolicy", new PluginType<>(entryCreator("loggernamelevelrewritepolicy", "org.apache.logging.log4j.core.appender.rewrite.LoggerNameLevelRewritePolicy", "LoggerNameLevelRewritePolicy", true, false, "Core"), org.apache.logging.log4j.core.appender.rewrite.LoggerNameLevelRewritePolicy.class, "LoggerNameLevelRewritePolicy"));
++                map.put("logger", new PluginType<>(entryCreator("logger", "org.apache.logging.log4j.core.config.LoggerConfig", "logger", true, false, "Core"), org.apache.logging.log4j.core.config.LoggerConfig.class, "logger"));
++                map.put("loggers", new PluginType<>(entryCreator("loggers", "org.apache.logging.log4j.core.config.LoggersPlugin", "loggers", false, false, "Core"), org.apache.logging.log4j.core.config.LoggersPlugin.class, "loggers"));
++                map.put("mapfilter", new PluginType<>(entryCreator("mapfilter", "org.apache.logging.log4j.core.filter.MapFilter", "MapFilter", true, false, "Core"), org.apache.logging.log4j.core.filter.MapFilter.class, "MapFilter"));
++                map.put("maprewritepolicy", new PluginType<>(entryCreator("maprewritepolicy", "org.apache.logging.log4j.core.appender.rewrite.MapRewritePolicy", "MapRewritePolicy", true, false, "Core"), org.apache.logging.log4j.core.appender.rewrite.MapRewritePolicy.class, "MapRewritePolicy"));
++                map.put("markerfilter", new PluginType<>(entryCreator("markerfilter", "org.apache.logging.log4j.core.filter.MarkerFilter", "MarkerFilter", true, false, "Core"), org.apache.logging.log4j.core.filter.MarkerFilter.class, "MarkerFilter"));
++                map.put("markerpatternselector", new PluginType<>(entryCreator("markerpatternselector", "org.apache.logging.log4j.core.layout.MarkerPatternSelector", "MarkerPatternSelector", true, false, "Core"), org.apache.logging.log4j.core.layout.MarkerPatternSelector.class, "MarkerPatternSelector"));
++                map.put("memorymappedfile", new PluginType<>(entryCreator("memorymappedfile", "org.apache.logging.log4j.core.appender.MemoryMappedFileAppender", "MemoryMappedFile", true, false, "Core"), org.apache.logging.log4j.core.appender.MemoryMappedFileAppender.class, "MemoryMappedFile"));
++                map.put("multicastdns", new PluginType<>(entryCreator("multicastdns", "org.apache.logging.log4j.core.net.MulticastDnsAdvertiser", "multicastdns", false, false, "Core"), org.apache.logging.log4j.core.net.MulticastDnsAdvertiser.class, "multicastdns"));
++                map.put("null", new PluginType<>(entryCreator("null", "org.apache.logging.log4j.core.appender.NullAppender", "Null", true, false, "Core"), org.apache.logging.log4j.core.appender.NullAppender.class, "Null"));
++                map.put("onstartuptriggeringpolicy", new PluginType<>(entryCreator("onstartuptriggeringpolicy", "org.apache.logging.log4j.core.appender.rolling.OnStartupTriggeringPolicy", "OnStartupTriggeringPolicy", true, false, "Core"), org.apache.logging.log4j.core.appender.rolling.OnStartupTriggeringPolicy.class, "OnStartupTriggeringPolicy"));
++                map.put("outputstream", new PluginType<>(entryCreator("outputstream", "org.apache.logging.log4j.core.appender.OutputStreamAppender", "OutputStream", true, false, "Core"), org.apache.logging.log4j.core.appender.OutputStreamAppender.class, "OutputStream"));
++                map.put("patternlayout", new PluginType<>(entryCreator("patternlayout", "org.apache.logging.log4j.core.layout.PatternLayout", "PatternLayout", true, false, "Core"), org.apache.logging.log4j.core.layout.PatternLayout.class, "PatternLayout"));
++                map.put("patternmatch", new PluginType<>(entryCreator("patternmatch", "org.apache.logging.log4j.core.layout.PatternMatch", "PatternMatch", true, false, "Core"), org.apache.logging.log4j.core.layout.PatternMatch.class, "PatternMatch"));
++                map.put("policies", new PluginType<>(entryCreator("policies", "org.apache.logging.log4j.core.appender.rolling.CompositeTriggeringPolicy", "Policies", true, false, "Core"), org.apache.logging.log4j.core.appender.rolling.CompositeTriggeringPolicy.class, "Policies"));
++                map.put("properties", new PluginType<>(entryCreator("properties", "org.apache.logging.log4j.core.config.PropertiesPlugin", "properties", true, false, "Core"), org.apache.logging.log4j.core.config.PropertiesPlugin.class, "properties"));
++                map.put("propertiesrewritepolicy", new PluginType<>(entryCreator("propertiesrewritepolicy", "org.apache.logging.log4j.core.appender.rewrite.PropertiesRewritePolicy", "PropertiesRewritePolicy", true, false, "Core"), org.apache.logging.log4j.core.appender.rewrite.PropertiesRewritePolicy.class, "PropertiesRewritePolicy"));
++                map.put("property", new PluginType<>(entryCreator("property", "org.apache.logging.log4j.core.config.Property", "property", true, false, "Core"), org.apache.logging.log4j.core.config.Property.class, "property"));
++                map.put("queue", new PluginType<>(entryCreator("queue", "com.mojang.util.QueueLogAppender", "Queue", true, false, "Core"), com.mojang.util.QueueLogAppender.class, "Queue"));
++                map.put("randomaccessfile", new PluginType<>(entryCreator("randomaccessfile", "org.apache.logging.log4j.core.appender.RandomAccessFileAppender", "RandomAccessFile", true, false, "Core"), org.apache.logging.log4j.core.appender.RandomAccessFileAppender.class, "RandomAccessFile"));
++                map.put("regexfilter", new PluginType<>(entryCreator("regexfilter", "org.apache.logging.log4j.core.filter.RegexFilter", "RegexFilter", true, false, "Core"), org.apache.logging.log4j.core.filter.RegexFilter.class, "RegexFilter"));
++                map.put("replace", new PluginType<>(entryCreator("replace", "org.apache.logging.log4j.core.pattern.RegexReplacement", "replace", true, false, "Core"), org.apache.logging.log4j.core.pattern.RegexReplacement.class, "replace"));
++                map.put("rewrite", new PluginType<>(entryCreator("rewrite", "org.apache.logging.log4j.core.appender.rewrite.RewriteAppender", "Rewrite", true, false, "Core"), org.apache.logging.log4j.core.appender.rewrite.RewriteAppender.class, "Rewrite"));
++                map.put("rfc5424layout", new PluginType<>(entryCreator("rfc5424layout", "org.apache.logging.log4j.core.layout.Rfc5424Layout", "Rfc5424Layout", true, false, "Core"), org.apache.logging.log4j.core.layout.Rfc5424Layout.class, "Rfc5424Layout"));
++                map.put("rollingfile", new PluginType<>(entryCreator("rollingfile", "org.apache.logging.log4j.core.appender.RollingFileAppender", "RollingFile", true, false, "Core"), org.apache.logging.log4j.core.appender.RollingFileAppender.class, "RollingFile"));
++                map.put("rollingrandomaccessfile", new PluginType<>(entryCreator("rollingrandomaccessfile", "org.apache.logging.log4j.core.appender.RollingRandomAccessFileAppender", "RollingRandomAccessFile", true, false, "Core"), org.apache.logging.log4j.core.appender.RollingRandomAccessFileAppender.class, "RollingRandomAccessFile"));
++                map.put("root", new PluginType<>(entryCreator("root", "org.apache.logging.log4j.core.config.LoggerConfig$RootLogger", "root", true, false, "Core"), org.apache.logging.log4j.core.config.LoggerConfig.RootLogger.class, "root"));
++                map.put("route", new PluginType<>(entryCreator("route", "org.apache.logging.log4j.core.appender.routing.Route", "Route", true, true, "Core"), org.apache.logging.log4j.core.appender.routing.Route.class, "Route"));
++                map.put("routes", new PluginType<>(entryCreator("routes", "org.apache.logging.log4j.core.appender.routing.Routes", "Routes", true, false, "Core"), org.apache.logging.log4j.core.appender.routing.Routes.class, "Routes"));
++                map.put("routing", new PluginType<>(entryCreator("routing", "org.apache.logging.log4j.core.appender.routing.RoutingAppender", "Routing", true, false, "Core"), org.apache.logging.log4j.core.appender.routing.RoutingAppender.class, "Routing"));
++                map.put("scriptappenderselector", new PluginType<>(entryCreator("scriptappenderselector", "org.apache.logging.log4j.core.appender.ScriptAppenderSelector", "ScriptAppenderSelector", true, false, "Core"), org.apache.logging.log4j.core.appender.ScriptAppenderSelector.class, "ScriptAppenderSelector"));
++                map.put("scriptcondition", new PluginType<>(entryCreator("scriptcondition", "org.apache.logging.log4j.core.appender.rolling.action.ScriptCondition", "ScriptCondition", true, false, "Core"), org.apache.logging.log4j.core.appender.rolling.action.ScriptCondition.class, "ScriptCondition"));
++                map.put("scriptfile", new PluginType<>(entryCreator("scriptfile", "org.apache.logging.log4j.core.script.ScriptFile", "ScriptFile", true, false, "Core"), org.apache.logging.log4j.core.script.ScriptFile.class, "ScriptFile"));
++                map.put("scriptfilter", new PluginType<>(entryCreator("scriptfilter", "org.apache.logging.log4j.core.filter.ScriptFilter", "ScriptFilter", true, false, "Core"), org.apache.logging.log4j.core.filter.ScriptFilter.class, "ScriptFilter"));
++                map.put("script", new PluginType<>(entryCreator("script", "org.apache.logging.log4j.core.script.Script", "Script", true, false, "Core"), org.apache.logging.log4j.core.script.Script.class, "Script"));
++                map.put("scriptpatternselector", new PluginType<>(entryCreator("scriptpatternselector", "org.apache.logging.log4j.core.layout.ScriptPatternSelector", "ScriptPatternSelector", true, false, "Core"), org.apache.logging.log4j.core.layout.ScriptPatternSelector.class, "ScriptPatternSelector"));
++                map.put("scriptref", new PluginType<>(entryCreator("scriptref", "org.apache.logging.log4j.core.script.ScriptRef", "ScriptRef", true, false, "Core"), org.apache.logging.log4j.core.script.ScriptRef.class, "ScriptRef"));
++                map.put("scripts", new PluginType<>(entryCreator("scripts", "org.apache.logging.log4j.core.config.ScriptsPlugin", "scripts", false, false, "Core"), org.apache.logging.log4j.core.config.ScriptsPlugin.class, "scripts"));
++                map.put("serializedlayout", new PluginType<>(entryCreator("serializedlayout", "org.apache.logging.log4j.core.layout.SerializedLayout", "SerializedLayout", true, false, "Core"), org.apache.logging.log4j.core.layout.SerializedLayout.class, "SerializedLayout"));
++                map.put("sizebasedtriggeringpolicy", new PluginType<>(entryCreator("sizebasedtriggeringpolicy", "org.apache.logging.log4j.core.appender.rolling.SizeBasedTriggeringPolicy", "SizeBasedTriggeringPolicy", true, false, "Core"), org.apache.logging.log4j.core.appender.rolling.SizeBasedTriggeringPolicy.class, "SizeBasedTriggeringPolicy"));
++                map.put("smtp", new PluginType<>(entryCreator("smtp", "org.apache.logging.log4j.core.appender.SmtpAppender", "SMTP", true, false, "Core"), org.apache.logging.log4j.core.appender.SmtpAppender.class, "SMTP"));
++                map.put("socketaddress", new PluginType<>(entryCreator("socketaddress", "org.apache.logging.log4j.core.net.SocketAddress", "SocketAddress", true, false, "Core"), org.apache.logging.log4j.core.net.SocketAddress.class, "SocketAddress"));
++                map.put("socket", new PluginType<>(entryCreator("socket", "org.apache.logging.log4j.core.appender.SocketAppender", "Socket", true, false, "Core"), org.apache.logging.log4j.core.appender.SocketAppender.class, "Socket"));
++                map.put("socketoptions", new PluginType<>(entryCreator("socketoptions", "org.apache.logging.log4j.core.net.SocketOptions", "SocketOptions", true, false, "Core"), org.apache.logging.log4j.core.net.SocketOptions.class, "SocketOptions"));
++                map.put("socketperformancepreferences", new PluginType<>(entryCreator("socketperformancepreferences", "org.apache.logging.log4j.core.net.SocketPerformancePreferences", "SocketPerformancePreferences", true, false, "Core"), org.apache.logging.log4j.core.net.SocketPerformancePreferences.class, "SocketPerformancePreferences"));
++                map.put("sortbymodificationtime", new PluginType<>(entryCreator("sortbymodificationtime", "org.apache.logging.log4j.core.appender.rolling.action.PathSortByModificationTime", "SortByModificationTime", true, false, "Core"), org.apache.logging.log4j.core.appender.rolling.action.PathSortByModificationTime.class, "SortByModificationTime"));
++                map.put("ssl", new PluginType<>(entryCreator("ssl", "org.apache.logging.log4j.core.net.ssl.SslConfiguration", "Ssl", true, false, "Core"), org.apache.logging.log4j.core.net.ssl.SslConfiguration.class, "Ssl"));
++                map.put("structureddatafilter", new PluginType<>(entryCreator("structureddatafilter", "org.apache.logging.log4j.core.filter.StructuredDataFilter", "StructuredDataFilter", true, false, "Core"), org.apache.logging.log4j.core.filter.StructuredDataFilter.class, "StructuredDataFilter"));
++                map.put("sysloglayout", new PluginType<>(entryCreator("sysloglayout", "org.apache.logging.log4j.core.layout.SyslogLayout", "SyslogLayout", true, false, "Core"), org.apache.logging.log4j.core.layout.SyslogLayout.class, "SyslogLayout"));
++                map.put("syslog", new PluginType<>(entryCreator("syslog", "org.apache.logging.log4j.core.appender.SyslogAppender", "Syslog", true, false, "Core"), org.apache.logging.log4j.core.appender.SyslogAppender.class, "Syslog"));
++                map.put("threadcontextmapfilter", new PluginType<>(entryCreator("threadcontextmapfilter", "org.apache.logging.log4j.core.filter.ThreadContextMapFilter", "ThreadContextMapFilter", true, false, "Core"), org.apache.logging.log4j.core.filter.ThreadContextMapFilter.class, "ThreadContextMapFilter"));
++                map.put("thresholdfilter", new PluginType<>(entryCreator("thresholdfilter", "org.apache.logging.log4j.core.filter.ThresholdFilter", "ThresholdFilter", true, false, "Core"), org.apache.logging.log4j.core.filter.ThresholdFilter.class, "ThresholdFilter"));
++                map.put("timebasedtriggeringpolicy", new PluginType<>(entryCreator("timebasedtriggeringpolicy", "org.apache.logging.log4j.core.appender.rolling.TimeBasedTriggeringPolicy", "TimeBasedTriggeringPolicy", true, false, "Core"), org.apache.logging.log4j.core.appender.rolling.TimeBasedTriggeringPolicy.class, "TimeBasedTriggeringPolicy"));
++                map.put("timefilter", new PluginType<>(entryCreator("timefilter", "org.apache.logging.log4j.core.filter.TimeFilter", "TimeFilter", true, false, "Core"), org.apache.logging.log4j.core.filter.TimeFilter.class, "TimeFilter"));
++                map.put("truststore", new PluginType<>(entryCreator("truststore", "org.apache.logging.log4j.core.net.ssl.TrustStoreConfiguration", "TrustStore", true, false, "Core"), org.apache.logging.log4j.core.net.ssl.TrustStoreConfiguration.class, "TrustStore"));
++                map.put("writer", new PluginType<>(entryCreator("writer", "org.apache.logging.log4j.core.appender.WriterAppender", "Writer", true, false, "Core"), org.apache.logging.log4j.core.appender.WriterAppender.class, "Writer"));
++                map.put("xmllayout", new PluginType<>(entryCreator("xmllayout", "org.apache.logging.log4j.core.layout.XmlLayout", "XmlLayout", true, false, "Core"), org.apache.logging.log4j.core.layout.XmlLayout.class, "XmlLayout"));
++                map.put("yamllayout", new PluginType<>(entryCreator("yamllayout", "org.apache.logging.log4j.core.layout.YamlLayout", "YamlLayout", true, false, "Core"), org.apache.logging.log4j.core.layout.YamlLayout.class, "YamlLayout"));
++                break;
++            case "FileConverter":
++                map.put("filedatepatternconverter", new PluginType<>(entryCreator("filedatepatternconverter", "org.apache.logging.log4j.core.pattern.FileDatePatternConverter", "FileDatePatternConverter", false, false, "FileConverter"), org.apache.logging.log4j.core.pattern.FileDatePatternConverter.class, "FileDatePatternConverter"));
++                map.put("integerpatternconverter", new PluginType<>(entryCreator("integerpatternconverter", "org.apache.logging.log4j.core.pattern.IntegerPatternConverter", "IntegerPatternConverter", false, false, "FileConverter"), org.apache.logging.log4j.core.pattern.IntegerPatternConverter.class, "IntegerPatternConverter"));
++                break;
++            case "Lookup":
++                map.put("bundle", new PluginType<>(entryCreator("bundle", "org.apache.logging.log4j.core.lookup.ResourceBundleLookup", "bundle", false, false, "Lookup"), org.apache.logging.log4j.core.lookup.ResourceBundleLookup.class, "bundle"));
++                map.put("ctx", new PluginType<>(entryCreator("ctx", "org.apache.logging.log4j.core.lookup.ContextMapLookup", "ctx", false, false, "Lookup"), org.apache.logging.log4j.core.lookup.ContextMapLookup.class, "ctx"));
++                map.put("date", new PluginType<>(entryCreator("date", "org.apache.logging.log4j.core.lookup.DateLookup", "date", false, false, "Lookup"), org.apache.logging.log4j.core.lookup.DateLookup.class, "date"));
++                map.put("env", new PluginType<>(entryCreator("env", "org.apache.logging.log4j.core.lookup.EnvironmentLookup", "env", false, false, "Lookup"), org.apache.logging.log4j.core.lookup.EnvironmentLookup.class, "env"));
++                map.put("java", new PluginType<>(entryCreator("java", "org.apache.logging.log4j.core.lookup.JavaLookup", "java", false, false, "Lookup"), org.apache.logging.log4j.core.lookup.JavaLookup.class, "java"));
++                map.put("jndi", new PluginType<>(entryCreator("jndi", "org.apache.logging.log4j.core.lookup.JndiLookup", "jndi", false, false, "Lookup"), org.apache.logging.log4j.core.lookup.JndiLookup.class, "jndi"));
++                map.put("jvmrunargs", new PluginType<>(entryCreator("jvmrunargs", "org.apache.logging.log4j.core.lookup.JmxRuntimeInputArgumentsLookup", "jvmrunargs", false, false, "Lookup"), org.apache.logging.log4j.core.lookup.JmxRuntimeInputArgumentsLookup.class, "jvmrunargs"));
++                map.put("log4j", new PluginType<>(entryCreator("log4j", "org.apache.logging.log4j.core.lookup.Log4jLookup", "log4j", false, false, "Lookup"), org.apache.logging.log4j.core.lookup.Log4jLookup.class, "log4j"));
++                map.put("main", new PluginType<>(entryCreator("main", "org.apache.logging.log4j.core.lookup.MainMapLookup", "main", false, false, "Lookup"), org.apache.logging.log4j.core.lookup.MainMapLookup.class, "main"));
++                map.put("map", new PluginType<>(entryCreator("map", "org.apache.logging.log4j.core.lookup.MapLookup", "map", false, false, "Lookup"), org.apache.logging.log4j.core.lookup.MapLookup.class, "map"));
++                map.put("marker", new PluginType<>(entryCreator("marker", "org.apache.logging.log4j.core.lookup.MarkerLookup", "marker", false, false, "Lookup"), org.apache.logging.log4j.core.lookup.MarkerLookup.class, "marker"));
++                map.put("sd", new PluginType<>(entryCreator("sd", "org.apache.logging.log4j.core.lookup.StructuredDataLookup", "sd", false, false, "Lookup"), org.apache.logging.log4j.core.lookup.StructuredDataLookup.class, "sd"));
++                map.put("sys", new PluginType<>(entryCreator("sys", "org.apache.logging.log4j.core.lookup.SystemPropertiesLookup", "sys", false, false, "Lookup"), org.apache.logging.log4j.core.lookup.SystemPropertiesLookup.class, "sys"));
++                break;
++            case "TypeConverter":
++                map.put("bigdecimal", new PluginType<>(entryCreator("bigdecimal", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$BigDecimalConverter", "BigDecimal", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.BigDecimalConverter.class, "BigDecimal"));
++                map.put("biginteger", new PluginType<>(entryCreator("biginteger", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$BigIntegerConverter", "BigInteger", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.BigIntegerConverter.class, "BigInteger"));
++                map.put("boolean", new PluginType<>(entryCreator("boolean", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$BooleanConverter", "Boolean", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.BooleanConverter.class, "Boolean"));
++                map.put("bytearray", new PluginType<>(entryCreator("bytearray", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$ByteArrayConverter", "ByteArray", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.ByteArrayConverter.class, "ByteArray"));
++                map.put("byte", new PluginType<>(entryCreator("byte", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$ByteConverter", "Byte", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.ByteConverter.class, "Byte"));
++                map.put("characterarray", new PluginType<>(entryCreator("characterarray", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$CharArrayConverter", "CharacterArray", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.CharArrayConverter.class, "CharacterArray"));
++                map.put("character", new PluginType<>(entryCreator("character", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$CharacterConverter", "Character", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.CharacterConverter.class, "Character"));
++                map.put("charset", new PluginType<>(entryCreator("charset", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$CharsetConverter", "Charset", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.CharsetConverter.class, "Charset"));
++                map.put("class", new PluginType<>(entryCreator("class", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$ClassConverter", "Class", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.ClassConverter.class, "Class"));
++                map.put("cronexpression", new PluginType<>(entryCreator("cronexpression", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$CronExpressionConverter", "CronExpression", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.CronExpressionConverter.class, "CronExpression"));
++                map.put("double", new PluginType<>(entryCreator("double", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$DoubleConverter", "Double", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.DoubleConverter.class, "Double"));
++                map.put("duration", new PluginType<>(entryCreator("duration", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$DurationConverter", "Duration", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.DurationConverter.class, "Duration"));
++                map.put("file", new PluginType<>(entryCreator("file", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$FileConverter", "File", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.FileConverter.class, "File"));
++                map.put("float", new PluginType<>(entryCreator("float", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$FloatConverter", "Float", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.FloatConverter.class, "Float"));
++                map.put("inetaddress", new PluginType<>(entryCreator("inetaddress", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$InetAddressConverter", "InetAddress", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.InetAddressConverter.class, "InetAddress"));
++                map.put("integer", new PluginType<>(entryCreator("integer", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$IntegerConverter", "Integer", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.IntegerConverter.class, "Integer"));
++                map.put("level", new PluginType<>(entryCreator("level", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$LevelConverter", "Level", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.LevelConverter.class, "Level"));
++                map.put("long", new PluginType<>(entryCreator("long", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$LongConverter", "Long", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.LongConverter.class, "Long"));
++                map.put("path", new PluginType<>(entryCreator("path", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$PathConverter", "Path", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.PathConverter.class, "Path"));
++                map.put("pattern", new PluginType<>(entryCreator("pattern", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$PatternConverter", "Pattern", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.PatternConverter.class, "Pattern"));
++                map.put("securityprovider", new PluginType<>(entryCreator("securityprovider", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$SecurityProviderConverter", "SecurityProvider", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.SecurityProviderConverter.class, "SecurityProvider"));
++                map.put("short", new PluginType<>(entryCreator("short", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$ShortConverter", "Short", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.ShortConverter.class, "Short"));
++                map.put("string", new PluginType<>(entryCreator("string", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$StringConverter", "String", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.StringConverter.class, "String"));
++                map.put("uri", new PluginType<>(entryCreator("uri", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$UriConverter", "URI", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.UriConverter.class, "URI"));
++                map.put("url", new PluginType<>(entryCreator("url", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$UrlConverter", "URL", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.UrlConverter.class, "URL"));
++                map.put("uuid", new PluginType<>(entryCreator("uuid", "org.apache.logging.log4j.core.config.plugins.convert.TypeConverters$UuidConverter", "UUID", false, false, "TypeConverter"), org.apache.logging.log4j.core.config.plugins.convert.TypeConverters.UuidConverter.class, "UUID"));
++                break;
++        }
++
++        this.plugins = map;
++    }
++}