CPD Results
The following document contains the results of PMD's CPD 5.3.5.
Duplications
File |
Line |
org/apache/logging/log4j/core/jackson/LogEventJsonMixIn.java |
49 |
org/apache/logging/log4j/core/jackson/LogEventMixIn.java |
51 |
@JacksonXmlProperty(namespace = XmlConstants.XML_NAMESPACE, localName = XmlConstants.ELT_CONTEXT_MAP)
// @JsonSerialize(using = MapSerializer.class)
// @JsonDeserialize(using = MapDeserializer.class)
@Override
public abstract Map<String, String> getContextMap();
@JsonProperty(JsonConstants.ELT_CONTEXT_STACK)
@JacksonXmlElementWrapper(namespace = XmlConstants.XML_NAMESPACE, localName = XmlConstants.ELT_CONTEXT_STACK)
@JacksonXmlProperty(namespace = XmlConstants.XML_NAMESPACE, localName = XmlConstants.ELT_CONTEXT_STACK_ITEM)
@Override
public abstract ContextStack getContextStack();
@JsonProperty()
@JacksonXmlProperty(isAttribute = true)
@Override
public abstract Level getLevel();
@JsonProperty()
@JacksonXmlProperty(isAttribute = true)
@Override
public abstract String getLoggerFqcn();
@JsonProperty()
@JacksonXmlProperty(isAttribute = true)
@Override
public abstract String getLoggerName();
@JsonProperty(JsonConstants.ELT_MARKER)
@JacksonXmlProperty(namespace = XmlConstants.XML_NAMESPACE, localName = XmlConstants.ELT_MARKER)
@Override
public abstract Marker getMarker();
@JsonProperty(JsonConstants.ELT_MESSAGE)
@JsonSerialize(using = MessageSerializer.class)
@JsonDeserialize(using = SimpleMessageDeserializer.class)
@JacksonXmlProperty(namespace = XmlConstants.XML_NAMESPACE, localName = XmlConstants.ELT_MESSAGE)
@Override
public abstract Message getMessage();
@JsonProperty(JsonConstants.ELT_SOURCE)
@JsonDeserialize(using = Log4jStackTraceElementDeserializer.class)
@JacksonXmlProperty(namespace = XmlConstants.XML_NAMESPACE, localName = XmlConstants.ELT_SOURCE)
@Override
public abstract StackTraceElement getSource();
@Override
@JsonProperty("threadId")
@JacksonXmlProperty(isAttribute = true, localName = "threadId")
public abstract long getThreadId();
@Override
@JsonProperty("thread")
@JacksonXmlProperty(isAttribute = true, localName = "thread")
public abstract String getThreadName();
@Override
@JsonProperty("threadPriority")
@JacksonXmlProperty(isAttribute = true, localName = "threadPriority")
public abstract int getThreadPriority();
@JsonIgnore
@Override
public abstract Throwable getThrown();
@JsonProperty(JsonConstants.ELT_THROWN)
@JacksonXmlProperty(namespace = XmlConstants.XML_NAMESPACE, localName = XmlConstants.ELT_THROWN)
@Override
public abstract ThrowableProxy getThrownProxy();
@JsonProperty()
@JacksonXmlProperty(isAttribute = true)
@Override
public abstract long getTimeMillis();
@JsonProperty()
@JacksonXmlProperty(isAttribute = true)
@Override
public abstract boolean isEndOfBatch();
@JsonIgnore
@Override
public abstract boolean isIncludeLocation();
@Override
public abstract void setEndOfBatch(boolean endOfBatch);
@Override
public abstract void setIncludeLocation(boolean locationRequired);
} |
File |
Line |
org/apache/logging/log4j/core/layout/JsonLayout.java |
814 |
org/apache/logging/log4j/core/layout/YamlLayout.java |
714 |
super(config, new JacksonFactory.JSON(encodeThreadContextAsList).newWriter(locationInfo, properties, compact),
charset, compact, complete, eventEol,
PatternLayout.createSerializer(config, null, headerPattern, DEFAULT_HEADER, null, false, false),
PatternLayout.createSerializer(config, null, footerPattern, DEFAULT_FOOTER, null, false, false));
}
/**
* Returns appropriate JSON header.
*
* @return a byte array containing the header, opening the JSON array.
*/
@Override
public byte[] getHeader() {
if (!this.complete) {
return null;
}
final StringBuilder buf = new StringBuilder();
final String str = serializeToString(getHeaderSerializer());
if (str != null) {
buf.append(str);
}
buf.append(this.eol);
return getBytes(buf.toString());
}
/**
* Returns appropriate JSON footer.
*
* @return a byte array containing the footer, closing the JSON array.
*/
@Override
public byte[] getFooter() {
if (!this.complete) {
return null;
}
final StringBuilder buf = new StringBuilder();
buf.append(this.eol);
final String str = serializeToString(getFooterSerializer());
if (str != null) {
buf.append(str);
}
buf.append(this.eol);
return getBytes(buf.toString());
}
@Override
public Map<String, String> getContentFormat() {
final Map<String, String> result = new HashMap<>();
result.put("version", "2.0");
return result;
}
@Override
/**
* @return The content type.
*/
public String getContentType() {
return CONTENT_TYPE + "; charset=" + this.getCharset();
}
/**
* Creates a JSON Layout.
* @param config
* The plugin configuration.
* @param locationInfo
* If "true", includes the location information in the generated JSON.
* @param properties
* If "true", includes the thread context map in the generated JSON.
* @param propertiesAsList
* If true, the thread context map is included as a list of map entry objects, where each entry has
* a "key" attribute (whose value is the key) and a "value" attribute (whose value is the value).
* Defaults to false, in which case the thread context map is included as a simple map of key-value
* pairs.
* @param complete
* If "true", includes the JSON header and footer, and comma between records.
* @param compact
* If "true", does not use end-of-lines and indentation, defaults to "false".
* @param eventEol
* If "true", forces an EOL after each log event (even if compact is "true"), defaults to "false". This
* allows one even per line, even in compact mode.
* @param headerPattern
* The header pattern, defaults to {@code "["} if null.
* @param footerPattern
* The header pattern, defaults to {@code "]"} if null.
* @param charset
* The character set to use, if {@code null}, uses "UTF-8".
* @return A JSON Layout.
*/
@PluginFactory
public static JsonLayout createLayout( |
File |
Line |
org/apache/logging/log4j/core/util/CronExpression.java |
1262 |
org/apache/logging/log4j/core/util/CronExpression.java |
1298 |
final java.util.Calendar tcal = java.util.Calendar.getInstance(getTimeZone());
tcal.set(Calendar.SECOND, 0);
tcal.set(Calendar.MINUTE, 0);
tcal.set(Calendar.HOUR_OF_DAY, 0);
tcal.set(Calendar.DAY_OF_MONTH, day);
tcal.set(Calendar.MONTH, mon - 1);
tcal.set(Calendar.YEAR, cl.get(Calendar.YEAR));
final int ldom = getLastDayOfMonth(mon, cl.get(Calendar.YEAR));
final int dow = tcal.get(Calendar.DAY_OF_WEEK);
if (dow == Calendar.SATURDAY && day == 1) {
day += 2;
} else if (dow == Calendar.SATURDAY) {
day -= 1;
} else if (dow == Calendar.SUNDAY && day == ldom) {
day -= 2;
} else if (dow == Calendar.SUNDAY) {
day += 1;
}
tcal.set(Calendar.SECOND, sec);
tcal.set(Calendar.MINUTE, min);
tcal.set(Calendar.HOUR_OF_DAY, hr);
tcal.set(Calendar.DAY_OF_MONTH, day);
tcal.set(Calendar.MONTH, mon - 1);
final Date nTime = tcal.getTime();
if (nTime.before(afterTime)) {
day = 1; |
File |
Line |
org/apache/logging/log4j/core/async/RingBufferLogEvent.java |
206 |
org/apache/logging/log4j/core/impl/MutableLogEvent.java |
217 |
}
/**
* @see ReusableMessage#getFormattedMessage()
*/
@Override
public String getFormattedMessage() {
return messageText.toString();
}
/**
* @see ReusableMessage#getFormat()
*/
@Override
public String getFormat() {
return null;
}
/**
* @see ReusableMessage#getParameters()
*/
@Override
public Object[] getParameters() {
return parameters == null ? null : Arrays.copyOf(parameters, parameterCount);
}
/**
* @see ReusableMessage#getThrowable()
*/
@Override
public Throwable getThrowable() {
return getThrown();
}
/**
* @see ReusableMessage#formatTo(StringBuilder)
*/
@Override
public void formatTo(final StringBuilder buffer) {
buffer.append(messageText);
}
/**
* Replaces this ReusableMessage's parameter array with the specified value and return the original array
* @param emptyReplacement the parameter array that can be used for subsequent uses of this reusable message
* @return the original parameter array
* @see ReusableMessage#swapParameters(Object[])
*/
@Override
public Object[] swapParameters(final Object[] emptyReplacement) {
final Object[] result = this.parameters;
this.parameters = emptyReplacement;
return result;
}
/*
* @see ReusableMessage#getParameterCount
*/
@Override
public short getParameterCount() {
return parameterCount;
}
@Override
public Message memento() {
if (message != null) {
return message;
}
final Object[] params = parameters == null ? new Object[0] : Arrays.copyOf(parameters, parameterCount);
return new ParameterizedMessage(messageText.toString(), params);
}
// CharSequence impl
@Override
public int length() { |
File |
Line |
org/apache/logging/log4j/core/layout/MarkerPatternSelector.java |
57 |
org/apache/logging/log4j/core/layout/ScriptPatternSelector.java |
66 |
final PatternParser parser = PatternLayout.createPatternParser(config);
for (final PatternMatch property : properties) {
try {
final List<PatternFormatter> list = parser.parse(property.getPattern(), alwaysWriteExceptions, noConsoleNoAnsi);
formatterMap.put(property.getKey(), list.toArray(new PatternFormatter[list.size()]));
patternMap.put(property.getKey(), property.getPattern());
} catch (final RuntimeException ex) {
throw new IllegalArgumentException("Cannot parse pattern '" + property.getPattern() + "'", ex);
}
}
try {
final List<PatternFormatter> list = parser.parse(defaultPattern, alwaysWriteExceptions, noConsoleNoAnsi);
defaultFormatters = list.toArray(new PatternFormatter[list.size()]);
this.defaultPattern = defaultPattern;
} catch (final RuntimeException ex) {
throw new IllegalArgumentException("Cannot parse pattern '" + defaultPattern + "'", ex);
}
}
@Override
public PatternFormatter[] getFormatters(final LogEvent event) {
final Marker marker = event.getMarker(); |
File |
Line |
org/apache/logging/log4j/core/config/AwaitCompletionReliabilityStrategy.java |
47 |
org/apache/logging/log4j/core/config/LockingReliabilityStrategy.java |
39 |
this.loggerConfig = Objects.requireNonNull(loggerConfig, "loggerConfig is null");
}
/*
* (non-Javadoc)
*
* @see org.apache.logging.log4j.core.config.ReliabilityStrategy#log(org.apache.logging.log4j.util.Supplier,
* java.lang.String, java.lang.String, org.apache.logging.log4j.Marker, org.apache.logging.log4j.Level,
* org.apache.logging.log4j.message.Message, java.lang.Throwable)
*/
@Override
public void log(final Supplier<LoggerConfig> reconfigured, final String loggerName, final String fqcn,
final Marker marker, final Level level, final Message data, final Throwable t) {
final LoggerConfig config = getActiveLoggerConfig(reconfigured);
try {
config.log(loggerName, fqcn, marker, level, data, t);
} finally {
config.getReliabilityStrategy().afterLogEvent();
}
}
/*
* (non-Javadoc)
*
* @see org.apache.logging.log4j.core.config.ReliabilityStrategy#log(org.apache.logging.log4j.util.Supplier,
* org.apache.logging.log4j.core.LogEvent)
*/
@Override
public void log(final Supplier<LoggerConfig> reconfigured, final LogEvent event) {
final LoggerConfig config = getActiveLoggerConfig(reconfigured);
try {
config.log(event);
} finally {
config.getReliabilityStrategy().afterLogEvent();
}
}
/*
* (non-Javadoc)
*
* @see
* org.apache.logging.log4j.core.config.ReliabilityStrategy#beforeLogEvent(org.apache.logging.log4j.core.config.
* LoggerConfig, org.apache.logging.log4j.util.Supplier)
*/
@Override
public LoggerConfig getActiveLoggerConfig(final Supplier<LoggerConfig> next) {
LoggerConfig result = this.loggerConfig;
if (!beforeLogEvent()) {
result = next.get();
return result.getReliabilityStrategy().getActiveLoggerConfig(next);
}
return result;
}
private boolean beforeLogEvent() { |
File |
Line |
org/apache/logging/log4j/core/appender/MemoryMappedFileAppender.java |
54 |
org/apache/logging/log4j/core/appender/RandomAccessFileAppender.java |
48 |
final Filter filter, final MemoryMappedFileManager manager, final String filename,
final boolean ignoreExceptions, final boolean immediateFlush, final Advertiser advertiser) {
super(name, layout, filter, ignoreExceptions, immediateFlush, manager);
if (advertiser != null) {
final Map<String, String> configuration = new HashMap<>(layout.getContentFormat());
configuration.putAll(manager.getContentFormat());
configuration.put("contentType", layout.getContentType());
configuration.put("name", name);
advertisement = advertiser.advertise(configuration);
}
this.fileName = filename;
this.advertiser = advertiser;
}
@Override
public void stop() {
super.stop();
if (advertiser != null) {
advertiser.unadvertise(advertisement);
}
}
/**
* Write the log entry rolling over the file when required.
*
* @param event The LogEvent.
*/
@Override
public void append(final LogEvent event) {
// Leverage the nice batching behaviour of async Loggers/Appenders:
// we can signal the file manager that it needs to flush the buffer
// to disk at the end of a batch.
// From a user's point of view, this means that all log events are
// _always_ available in the log file, without incurring the overhead
// of immediateFlush=true.
getManager().setEndOfBatch(event.isEndOfBatch()); // FIXME manager's EndOfBatch threadlocal can be deleted
super.append(event); // TODO should only call force() if immediateFlush && endOfBatch?
}
/**
* Returns the file name this appender is associated with.
*
* @return The File name.
*/
public String getFileName() {
return this.fileName;
}
/**
* Returns the length of the memory mapped region.
*
* @return the length of the memory mapped region
*/
public int getRegionLength() { |
File |
Line |
org/apache/logging/log4j/core/filter/MapFilter.java |
127 |
org/apache/logging/log4j/core/filter/StructuredDataFilter.java |
112 |
org/apache/logging/log4j/core/filter/ThreadContextMapFilter.java |
122 |
LOGGER.error("keys and values must be specified for the MapFilter");
return null;
}
final Map<String, List<String>> map = new HashMap<>();
for (final KeyValuePair pair : pairs) {
final String key = pair.getKey();
if (key == null) {
LOGGER.error("A null key is not valid in MapFilter");
continue;
}
final String value = pair.getValue();
if (value == null) {
LOGGER.error("A null value for key " + key + " is not allowed in MapFilter");
continue;
}
List<String> list = map.get(pair.getKey());
if (list != null) {
list.add(value);
} else {
list = new ArrayList<>();
list.add(value);
map.put(pair.getKey(), list);
}
}
if (map.isEmpty()) {
LOGGER.error("MapFilter is not configured with any valid key value pairs"); |
File |
Line |
org/apache/logging/log4j/core/async/AsyncLoggerConfigDefaultExceptionHandler.java |
29 |
org/apache/logging/log4j/core/async/AsyncLoggerDefaultExceptionHandler.java |
27 |
final AsyncLoggerConfigDisruptor.Log4jEventWrapper event) {
final StringBuilder sb = new StringBuilder(512);
sb.append("AsyncLogger error handling event seq=").append(sequence).append(", value='");
try {
sb.append(event);
} catch (final Exception ignored) {
sb.append("[ERROR calling ").append(event.getClass()).append(".toString(): ");
sb.append(ignored).append("]");
}
sb.append("':");
System.err.println(sb);
throwable.printStackTrace();
}
@Override
public void handleOnStartException(final Throwable throwable) {
System.err.println("AsyncLogger error starting:");
throwable.printStackTrace();
}
@Override
public void handleOnShutdownException(final Throwable throwable) {
System.err.println("AsyncLogger error shutting down:");
throwable.printStackTrace();
}
} |
File |
Line |
org/apache/logging/log4j/core/layout/MarkerPatternSelector.java |
103 |
org/apache/logging/log4j/core/layout/ScriptPatternSelector.java |
124 |
return new MarkerPatternSelector(properties, defaultPattern, alwaysWriteExceptions,
noConsoleNoAnsi, config);
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder();
boolean first = true;
for (final Map.Entry<String, String> entry : patternMap.entrySet()) {
if (!first) {
sb.append(", ");
}
sb.append("key=\"").append(entry.getKey()).append("\", pattern=\"").append(entry.getValue()).append("\"");
first = false;
}
if (!first) {
sb.append(", ");
}
sb.append("default=\"").append(defaultPattern).append("\"");
return sb.toString();
}
} |
File |
Line |
org/apache/logging/log4j/core/appender/FileAppender.java |
48 |
org/apache/logging/log4j/core/appender/MemoryMappedFileAppender.java |
54 |
org/apache/logging/log4j/core/appender/RandomAccessFileAppender.java |
48 |
final FileManager manager, final String filename, final boolean ignoreExceptions,
final boolean immediateFlush, final Advertiser advertiser) {
super(name, layout, filter, ignoreExceptions, immediateFlush, manager);
if (advertiser != null) {
final Map<String, String> configuration = new HashMap<>(layout.getContentFormat());
configuration.putAll(manager.getContentFormat());
configuration.put("contentType", layout.getContentType());
configuration.put("name", name);
advertisement = advertiser.advertise(configuration);
}
this.fileName = filename;
this.advertiser = advertiser;
}
@Override
public void stop() {
super.stop();
if (advertiser != null) {
advertiser.unadvertise(advertisement);
}
} |
File |
Line |
org/apache/logging/log4j/core/layout/CsvLogEventLayout.java |
53 |
org/apache/logging/log4j/core/layout/CsvParameterLayout.java |
62 |
public static CsvLogEventLayout createLayout(
// @formatter:off
@PluginConfiguration final Configuration config,
@PluginAttribute(value = "format", defaultString = DEFAULT_FORMAT) final String format,
@PluginAttribute("delimiter") final Character delimiter,
@PluginAttribute("escape") final Character escape,
@PluginAttribute("quote") final Character quote,
@PluginAttribute("quoteMode") final QuoteMode quoteMode,
@PluginAttribute("nullString") final String nullString,
@PluginAttribute("recordSeparator") final String recordSeparator,
@PluginAttribute(value = "charset", defaultString = DEFAULT_CHARSET) final Charset charset,
@PluginAttribute("header") final String header,
@PluginAttribute("footer") final String footer)
// @formatter:on
{
final CSVFormat csvFormat = createFormat(format, delimiter, escape, quote, quoteMode, nullString, recordSeparator);
return new CsvLogEventLayout(config, charset, csvFormat, header, footer); |
File |
Line |
org/apache/logging/log4j/core/config/AwaitUnconditionallyReliabilityStrategy.java |
45 |
org/apache/logging/log4j/core/config/DefaultReliabilityStrategy.java |
36 |
DEFAULT_SLEEP_MILLIS);
}
/*
* (non-Javadoc)
*
* @see org.apache.logging.log4j.core.config.ReliabilityStrategy#log(org.apache.logging.log4j.util.Supplier,
* java.lang.String, java.lang.String, org.apache.logging.log4j.Marker, org.apache.logging.log4j.Level,
* org.apache.logging.log4j.message.Message, java.lang.Throwable)
*/
@Override
public void log(final Supplier<LoggerConfig> reconfigured, final String loggerName, final String fqcn, final Marker marker, final Level level,
final Message data, final Throwable t) {
loggerConfig.log(loggerName, fqcn, marker, level, data, t);
}
/*
* (non-Javadoc)
*
* @see org.apache.logging.log4j.core.config.ReliabilityStrategy#log(org.apache.logging.log4j.util.Supplier,
* org.apache.logging.log4j.core.LogEvent)
*/
@Override
public void log(final Supplier<LoggerConfig> reconfigured, final LogEvent event) {
loggerConfig.log(event);
}
/*
* (non-Javadoc)
*
* @see
* org.apache.logging.log4j.core.config.ReliabilityStrategy#beforeLogEvent(org.apache.logging.log4j.core.config.
* LoggerConfig, org.apache.logging.log4j.util.Supplier)
*/
@Override
public LoggerConfig getActiveLoggerConfig(final Supplier<LoggerConfig> next) {
return this.loggerConfig;
}
/*
* (non-Javadoc)
*
* @see org.apache.logging.log4j.core.config.ReliabilityStrategy#afterLogEvent()
*/
@Override
public void afterLogEvent() {
// no action
}
/*
* (non-Javadoc)
*
* @see org.apache.logging.log4j.core.config.ReliabilityStrategy#beforeStopAppenders()
*/
@Override
public void beforeStopAppenders() {
// no action
}
/*
* (non-Javadoc)
*
* @see
* org.apache.logging.log4j.core.config.ReliabilityStrategy#beforeStopConfiguration(org.apache.logging.log4j.core
* .config.Configuration)
*/
@Override
public void beforeStopConfiguration(final Configuration configuration) { |
File |
Line |
org/apache/logging/log4j/core/appender/RollingFileAppender.java |
162 |
org/apache/logging/log4j/core/appender/RollingRandomAccessFileAppender.java |
178 |
if (name == null) {
LOGGER.error("No name provided for FileAppender");
return null;
}
if (fileName == null) {
LOGGER.error("No filename was provided for FileAppender with name " + name);
return null;
}
if (filePattern == null) {
LOGGER.error("No filename pattern provided for FileAppender with name " + name);
return null;
}
if (policy == null) {
LOGGER.error("A TriggeringPolicy must be provided");
return null;
}
if (strategy == null) {
strategy = DefaultRolloverStrategy.createStrategy(null, null, null,
String.valueOf(Deflater.DEFAULT_COMPRESSION), null, true, config);
}
if (layout == null) {
layout = PatternLayout.createDefaultLayout();
}
final RollingFileManager manager = RollingFileManager.getFileManager(fileName, filePattern, isAppend, |
File |
Line |
org/apache/logging/log4j/core/net/server/TcpSocketServer.java |
171 |
org/apache/logging/log4j/core/net/server/UdpSocketServer.java |
96 |
return LOGGER.exit(socketServer);
}
/**
* Main startup for the server.
*
* @param args
* The command line arguments.
* @throws Exception
* if an error occurs.
*/
public static void main(final String[] args) throws Exception {
if (args.length < 1 || args.length > 2) {
System.err.println("Incorrect number of arguments");
printUsage();
return;
}
final int port = Integer.parseInt(args[0]);
if (port <= 0 || port >= MAX_PORT) {
System.err.println("Invalid port number");
printUsage();
return;
}
if (args.length == 2 && args[1].length() > 0) {
ConfigurationFactory.setConfigurationFactory(new ServerConfigurationFactory(args[1]));
}
final TcpSocketServer<ObjectInputStream> socketServer = TcpSocketServer.createSerializedSocketServer(port); |
File |
Line |
org/apache/logging/log4j/core/async/RingBufferLogEvent.java |
115 |
org/apache/logging/log4j/core/impl/MutableLogEvent.java |
192 |
private void setMessage(final Message msg) {
if (msg instanceof ReusableMessage) {
final ReusableMessage reusable = (ReusableMessage) msg;
reusable.formatTo(getMessageTextForWriting());
if (parameters != null) {
parameters = reusable.swapParameters(parameters);
parameterCount = reusable.getParameterCount();
}
} else {
// if the Message instance is reused, there is no point in freezing its message here
if (!Constants.FORMAT_MESSAGES_IN_BACKGROUND && msg != null) { // LOG4J2-898: user may choose
msg.getFormattedMessage(); // LOG4J2-763: ask message to freeze parameters
}
this.message = msg;
}
}
private StringBuilder getMessageTextForWriting() {
if (messageText == null) {
// Should never happen:
// only happens if user logs a custom reused message when Constants.ENABLE_THREADLOCALS is false
messageText = new StringBuilder(Constants.INITIAL_REUSABLE_MESSAGE_SIZE);
}
messageText.setLength(0);
return messageText;
} |
File |
Line |
org/apache/logging/log4j/core/util/CronExpression.java |
1360 |
org/apache/logging/log4j/core/util/CronExpression.java |
1451 |
int daysToAdd = 0;
if (cDow < dow) {
daysToAdd = dow - cDow;
}
if (cDow > dow) {
daysToAdd = dow + (7 - cDow);
}
final int lDay = getLastDayOfMonth(mon, cl.get(Calendar.YEAR));
if (day + daysToAdd > lDay) { // did we already miss the
// last one?
cl.set(Calendar.SECOND, 0);
cl.set(Calendar.MINUTE, 0);
cl.set(Calendar.HOUR_OF_DAY, 0);
cl.set(Calendar.DAY_OF_MONTH, 1);
cl.set(Calendar.MONTH, mon);
// no '- 1' here because we are promoting the month
continue;
} |
File |
Line |
org/apache/logging/log4j/core/util/CronExpression.java |
768 |
org/apache/logging/log4j/core/util/CronExpression.java |
794 |
if (i < s.length() && ((c = s.charAt(i)) == '/')) {
i++;
c = s.charAt(i);
final int v2 = Integer.parseInt(String.valueOf(c));
i++;
if (i >= s.length()) {
addToSet(val, end, v2, type);
return i;
}
c = s.charAt(i);
if (c >= '0' && c <= '9') {
final ValueSet vs = getValue(v2, s, i);
final int v3 = vs.value;
addToSet(val, end, v3, type);
i = vs.pos;
return i;
} else { |
File |
Line |
org/apache/logging/log4j/core/config/composite/CompositeConfiguration.java |
85 |
org/apache/logging/log4j/core/config/xml/XmlConfiguration.java |
117 |
statusConfig.withStatus(value.toUpperCase());
} else if ("dest".equalsIgnoreCase(key)) {
statusConfig.withDestination(value);
} else if ("shutdownHook".equalsIgnoreCase(key)) {
isShutdownHookEnabled = !"disable".equalsIgnoreCase(value);
} else if ("verbose".equalsIgnoreCase(key)) {
statusConfig.withVerbosity(value);
} else if ("packages".equalsIgnoreCase(key)) {
pluginPackages.addAll(Arrays.asList(value.split(Patterns.COMMA_SEPARATOR)));
} else if ("name".equalsIgnoreCase(key)) {
setName(value);
} |
File |
Line |
org/apache/logging/log4j/core/layout/PatternLayout.java |
292 |
org/apache/logging/log4j/core/layout/PatternLayout.java |
342 |
final int len = formatters.length;
for (int i = 0; i < len; i++) {
formatters[i].format(event, buffer);
}
if (replace != null) { // creates temporary objects
String str = buffer.toString();
str = replace.format(str);
buffer.setLength(0);
buffer.append(str);
}
return buffer;
}
@Override
public String toString() {
final StringBuilder builder = new StringBuilder();
builder.append(super.toString());
builder.append("[formatters="); |
File |
Line |
org/apache/logging/log4j/core/appender/RollingFileAppender.java |
143 |
org/apache/logging/log4j/core/appender/RollingRandomAccessFileAppender.java |
162 |
@PluginAttribute("immediateFlush") final String immediateFlush,
@PluginElement("Policy") final TriggeringPolicy policy,
@PluginElement("Strategy") RolloverStrategy strategy,
@PluginElement("Layout") Layout<? extends Serializable> layout,
@PluginElement("Filter") final Filter filter,
@PluginAttribute("ignoreExceptions") final String ignore,
@PluginAttribute("advertise") final String advertise,
@PluginAttribute("advertiseURI") final String advertiseURI,
@PluginConfiguration final Configuration config) {
final boolean isAppend = Booleans.parseBoolean(append, true);
final boolean ignoreExceptions = Booleans.parseBoolean(ignore, true);
final boolean isBuffered = Booleans.parseBoolean(bufferedIO, true); |
|