mirror of
https://github.com/LegacyModdingMC/UniMix.git
synced 2026-11-21 23:12:11 +00:00
186 lines
5.6 KiB
Java
186 lines
5.6 KiB
Java
/*
|
|
* This file is part of Mixin, licensed under the MIT License (MIT).
|
|
*
|
|
* Copyright (c) SpongePowered <https://www.spongepowered.org>
|
|
* Copyright (c) contributors
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
package org.spongepowered.asm.logging;
|
|
|
|
/**
|
|
* Abstract base adapter which contains a convenience class for formatting
|
|
* log4j2-style messages and also routes all level-specific overloads to calls
|
|
* to <tt>log</tt>, which can simplify some implementations.
|
|
*/
|
|
public abstract class LoggerAdapterAbstract implements ILogger {
|
|
|
|
/**
|
|
* This is a very naive implementation of log4j2's <tt>ParameterizedMessage
|
|
* </tt> which is less efficient and less defensive because it doesn't need
|
|
* to handle all the cases that the log4j2 formatter does. All we're really
|
|
* doing here is substituting in the values for <tt>{}</tt> placeholders
|
|
* because I know that in mixin there aren't any cases where we need to
|
|
* handle anything else, such as escaped <tt>{</tt> characters or whatever.
|
|
* It also handles the case where the last param of the varargs is a
|
|
* <tt>Throwable</tt>, and makes it available to consumers.
|
|
*/
|
|
public static class FormattedMessage {
|
|
|
|
private String message;
|
|
|
|
private Throwable t;
|
|
|
|
/**
|
|
* Create a new formatted message
|
|
*
|
|
* @param message Message patterm
|
|
* @param params Message parameters
|
|
*/
|
|
public FormattedMessage(String message, Object... params) {
|
|
if (params.length == 0) {
|
|
this.message = message;
|
|
return;
|
|
}
|
|
StringBuilder sb = new StringBuilder();
|
|
int pos = 0, param = 0;
|
|
for (; pos < message.length() && param < params.length; param++) {
|
|
int delimPos = message.indexOf("{}", pos);
|
|
if (delimPos < 0) {
|
|
break;
|
|
}
|
|
sb.append(message.substring(pos, delimPos)).append(params[param]);
|
|
pos = delimPos + 2;
|
|
}
|
|
if (pos < message.length()) {
|
|
sb.append(message.substring(pos));
|
|
}
|
|
// If last arg is throwable and not consumed by the message, store it
|
|
if (param < params.length && params[params.length - 1] instanceof Throwable) {
|
|
this.t = (Throwable)params[params.length - 1];
|
|
}
|
|
this.message = sb.toString();
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return this.message;
|
|
}
|
|
|
|
public String getMessage() {
|
|
return this.message;
|
|
}
|
|
|
|
public boolean hasThrowable() {
|
|
return this.t != null;
|
|
}
|
|
|
|
public Throwable getThrowable() {
|
|
return this.t;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Logger id
|
|
*/
|
|
private final String id;
|
|
|
|
/**
|
|
* @param id Logger id
|
|
*/
|
|
protected LoggerAdapterAbstract(String id) {
|
|
this.id = id;
|
|
}
|
|
|
|
/**
|
|
* Get the id of this logger
|
|
*/
|
|
@Override
|
|
public String getId() {
|
|
return this.id;
|
|
}
|
|
|
|
@Override
|
|
public void catching(Throwable t) {
|
|
this.catching(Level.WARN, t);
|
|
}
|
|
|
|
@Override
|
|
public void debug(String message, Object... params) {
|
|
this.log(Level.DEBUG, message, params);
|
|
}
|
|
|
|
@Override
|
|
public void debug(String message, Throwable t) {
|
|
this.log(Level.DEBUG, message, t);
|
|
}
|
|
|
|
@Override
|
|
public void error(String message, Object... params) {
|
|
this.log(Level.ERROR, message, params);
|
|
}
|
|
|
|
@Override
|
|
public void error(String message, Throwable t) {
|
|
this.log(Level.ERROR, message, t);
|
|
}
|
|
|
|
@Override
|
|
public void fatal(String message, Object... params) {
|
|
this.log(Level.FATAL, message, params);
|
|
}
|
|
|
|
@Override
|
|
public void fatal(String message, Throwable t) {
|
|
this.log(Level.FATAL, message, t);
|
|
}
|
|
|
|
@Override
|
|
public void info(String message, Object... params) {
|
|
this.log(Level.INFO, message, params);
|
|
}
|
|
|
|
@Override
|
|
public void info(String message, Throwable t) {
|
|
this.log(Level.INFO, message, t);
|
|
}
|
|
|
|
@Override
|
|
public void trace(String message, Object... params) {
|
|
this.log(Level.TRACE, message, params);
|
|
}
|
|
|
|
@Override
|
|
public void trace(String message, Throwable t) {
|
|
this.log(Level.TRACE, message, t);
|
|
}
|
|
|
|
@Override
|
|
public void warn(String message, Object... params) {
|
|
this.log(Level.WARN, message, params);
|
|
}
|
|
|
|
@Override
|
|
public void warn(String message, Throwable t) {
|
|
this.log(Level.WARN, message, t);
|
|
}
|
|
|
|
}
|