From 41a08a5f42d5ab4fa0082536ad496ff93c21f712 Mon Sep 17 00:00:00 2001 From: Lixfel Date: Fri, 17 Sep 2021 10:53:40 +0200 Subject: [PATCH] Preinitialized log4j PluginManager for Spigot --- .../Preinitialized_log4j_PluginManager.patch | 275 ++++++++++++++++++ 1 file changed, 275 insertions(+) create mode 100644 Spigot/SteamWar-Patches/Preinitialized_log4j_PluginManager.patch diff --git a/Spigot/SteamWar-Patches/Preinitialized_log4j_PluginManager.patch b/Spigot/SteamWar-Patches/Preinitialized_log4j_PluginManager.patch new file mode 100644 index 0000000..8a06886 --- /dev/null +++ b/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> 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 packages) { ++ //unused ++ } ++ ++ public PluginType getPluginType(String name) { ++ return this.plugins.get(name.toLowerCase()); ++ } ++ ++ public Map> 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 packages) { ++ Map> 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; ++ } ++}