Skip to content

Commit 2e23158

Browse files
JonathingJonathing
committed
Log Utils 0.5 - Tagging and global indentation/capturing (#17)
1 parent aaca627 commit 2e23158

File tree

5 files changed

+73
-111
lines changed

5 files changed

+73
-111
lines changed

‎log-utils/src/main/java/net/minecraftforge/util/logging/AbstractLogger.java‎

Lines changed: 35 additions & 60 deletions
Original file line numberDiff line numberDiff line change
@@ -7,83 +7,73 @@
77
import org.jetbrains.annotations.Nullable;
88

99
import java.util.AbstractMap;
10-
import java.util.ArrayList;
11-
import java.util.Iterator;
12-
import java.util.List;
1310
import java.util.Map;
14-
import java.util.function.BiConsumer;
11+
import java.util.Queue;
12+
import java.util.concurrent.ConcurrentLinkedQueue;
1513
import java.util.function.Consumer;
1614

1715
public abstract class AbstractLogger implements Logger {
1816
/* CREATION */
1917

2018
protected AbstractLogger() {
21-
this(Level.INFO, (byte) 0);
19+
this.tag = "";
2220
}
2321

24-
protected AbstractLogger(byte indentLevel) {
25-
this(Level.INFO, indentLevel);
26-
}
27-
28-
protected AbstractLogger(Level enabled) {
29-
this(enabled, (byte) 0);
30-
}
31-
32-
protected AbstractLogger(Level enabled, byte indentLevel) {
33-
this.enabled = enabled;
34-
this.indentLevel = indentLevel;
22+
protected AbstractLogger(String tag) {
23+
this.tag = '[' + tag + "] ";
3524
}
3625

3726
/* LOG LEVELS */
3827

39-
private @Nullable Level enabled;
28+
private static @Nullable Level enabled = Level.INFO;
4029

41-
@Override
42-
public final @Nullable Level getEnabled() {
43-
return this.enabled;
30+
static @Nullable Level getEnabledImpl() {
31+
return enabled;
4432
}
4533

46-
@Override
47-
public final void setEnabled(@Nullable Level level) {
48-
this.enabled = level;
34+
static void setEnabledImpl(@Nullable Level level) {
35+
enabled = level;
4936
}
5037

38+
static boolean isEnabledImpl(Level level) {
39+
return enabled != null && level.compareTo(enabled) >= 0;
40+
}
41+
42+
/* TAGGING */
43+
44+
final String tag;
45+
5146
/* INDENTATIONS */
5247

5348
private static final String INDENT_STRING = " ";
54-
private static final String[] INDENT_CACHE = new String[Byte.MAX_VALUE];
55-
private byte indentLevel;
49+
private static final @Nullable String[] INDENT_CACHE = new String[Byte.MAX_VALUE];
50+
private static byte indentLevel;
5651

5752
static {
5853
INDENT_CACHE[0] = "";
5954
INDENT_CACHE[1] = INDENT_STRING;
6055
}
6156

62-
@Override
63-
public final byte push() {
57+
static byte pushImpl() {
6458
return indentLevel++;
6559
}
6660

67-
@Override
68-
public final byte pop() {
61+
static byte popImpl() {
6962
if (--indentLevel < 0)
7063
throw new IllegalStateException("Cannot pop Log below 0");
7164

7265
return indentLevel;
7366
}
7467

75-
@Override
76-
public final byte pop(byte indent) {
68+
static byte popImpl(byte indent) {
7769
if (indent < 0)
7870
throw new IllegalArgumentException("Cannot pop Log below 0");
7971

8072
return indentLevel = indent;
8173
}
8274

83-
@Override
84-
public final String getIndentation() {
75+
final String getIndentationImpl() {
8576
String ret = INDENT_CACHE[indentLevel];
86-
//noinspection ConstantValue -- IntelliJ skill issue
8777
return ret == null ? INDENT_CACHE[indentLevel] = getIndentation(indentLevel) : ret;
8878
}
8979

@@ -96,53 +86,38 @@ private static String getIndentation(byte indent) {
9686

9787
/* CAPTURING */
9888

99-
private @Nullable List<Map.Entry<Level, String>> captured;
89+
private static @Nullable Queue<Map.Entry<Consumer<? super String>, String>> captured;
10090

101-
@Override
102-
public final boolean isCapturing() {
91+
static boolean isCapturingImpl() {
10392
return captured != null;
10493
}
10594

106-
@Override
107-
public final void capture() {
95+
static void captureImpl() {
10896
if (captured != null) return;
109-
captured = new ArrayList<>(128);
97+
captured = new ConcurrentLinkedQueue<>();
11098
}
11199

112-
final void tryCapture(Consumer<? super String> logger, Level level, String message) {
100+
static void tryCapture(Consumer<? super String> logger, String message) {
113101
if (captured != null)
114-
captured.add(new AbstractMap.SimpleImmutableEntry<>(level, message));
102+
captured.add(new AbstractMap.SimpleImmutableEntry<>(logger, message));
115103
else
116104
logger.accept(message);
117105
}
118106

119-
@Override
120-
public final void drop() {
107+
static void dropImpl() {
121108
captured = null;
122109
}
123110

124-
@Override
125-
public final void release() {
126-
release(this::logDirectly);
127-
}
128-
129-
@Override
130-
public final void release(BiConsumer<Level, String> consumer) {
111+
static void releaseImpl() {
131112
if (captured == null) return;
132113

133-
Iterator<Map.Entry<Level, String>> itor = captured.iterator();
134-
captured = null;
135-
while (itor.hasNext()) {
136-
Map.Entry<Level, String> capture = itor.next();
137-
consumer.accept(capture.getKey(), capture.getValue());
114+
for (Map.Entry<Consumer<? super String>, String> capture : captured) {
115+
capture.getKey().accept(capture.getValue());
138116
}
117+
captured = null;
139118
}
140119

141120
/* LOGGING */
142121

143122
static final DelegatePrintStream.Empty EMPTY = DelegatePrintStream.EMPTY;
144-
145-
private void logDirectly(Level level, String message) {
146-
((DelegatePrintStream) this.getLog(level)).getDelegate().accept(message);
147-
}
148123
}

‎log-utils/src/main/java/net/minecraftforge/util/logging/DefaultLogger.java‎

Lines changed: 2 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -11,16 +11,8 @@ final class DefaultLogger extends AbstractLogger {
1111
super();
1212
}
1313

14-
DefaultLogger(byte indentLevel) {
15-
super(indentLevel);
16-
}
17-
18-
DefaultLogger(Level enabled) {
19-
super(enabled);
20-
}
21-
22-
DefaultLogger(Level enabled, byte indentLevel) {
23-
super(enabled, indentLevel);
14+
DefaultLogger(String tag) {
15+
super(tag);
2416
}
2517

2618
private final DelegatePrintStream.Capturing debug = new DelegatePrintStream.Capturing(this, Level.DEBUG, System.out::println);

‎log-utils/src/main/java/net/minecraftforge/util/logging/DelegatePrintStream.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ final class Capturing extends PrintStream implements DelegatePrintStream {
1818

1919
public Capturing(AbstractLogger logger, Logger.Level level, Consumer<? super String> output) {
2020
super(new OutputStream() {
21-
private final Consumer<? super String> consumer = new LogConsumer(logger, level, output);
21+
private final Consumer<? super String> consumer = new LogConsumer(level, output);
2222
private StringBuffer buffer = new StringBuffer(512);
2323

2424
@Override
@@ -29,7 +29,7 @@ public void write(int b) {
2929
private void write(char c) {
3030
if (c == '\n' || c == '\r') {
3131
if (this.buffer.length() != 0) {
32-
consumer.accept(this.buffer.insert(0, logger.getIndentation()).toString());
32+
consumer.accept(this.buffer.insert(0, logger.getIndentationImpl() + logger.tag).toString());
3333
this.buffer = new StringBuffer(512);
3434
}
3535
} else {

‎log-utils/src/main/java/net/minecraftforge/util/logging/LogConsumer.java‎

Lines changed: 3 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -7,24 +7,22 @@
77
import java.util.function.Consumer;
88

99
final class LogConsumer implements Consumer<String> {
10-
private final AbstractLogger logger;
1110
private final Logger.Level level;
1211
private final Consumer<? super String> output;
1312

14-
LogConsumer(AbstractLogger logger, Logger.Level level, Consumer<? super String> output) {
15-
this.logger = logger;
13+
LogConsumer(Logger.Level level, Consumer<? super String> output) {
1614
this.level = level;
1715
this.output = output;
1816
}
1917

2018
private boolean isEnabled() {
21-
return this.logger.isEnabled(this.level);
19+
return AbstractLogger.isEnabledImpl(this.level);
2220
}
2321

2422
@Override
2523
public void accept(String message) {
2624
if (!this.isEnabled()) return;
2725

28-
this.logger.tryCapture(this.output, this.level, message);
26+
AbstractLogger.tryCapture(this.output, message);
2927
}
3028
}

‎log-utils/src/main/java/net/minecraftforge/util/logging/Logger.java‎

Lines changed: 31 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,6 @@
77
import org.jetbrains.annotations.Nullable;
88

99
import java.io.PrintStream;
10-
import java.util.function.BiConsumer;
1110

1211
public interface Logger {
1312
/* CREATION */
@@ -16,16 +15,8 @@ static Logger create() {
1615
return new DefaultLogger();
1716
}
1817

19-
static Logger create(byte indentLevel) {
20-
return new DefaultLogger(indentLevel);
21-
}
22-
23-
static Logger create(Level enabled) {
24-
return new DefaultLogger(enabled);
25-
}
26-
27-
static Logger create(Level enabled, byte indentLevel) {
28-
return new DefaultLogger(enabled, indentLevel);
18+
static Logger create(String tag) {
19+
return new DefaultLogger(tag);
2920
}
3021

3122
/* LOG LEVELS */
@@ -35,24 +26,31 @@ enum Level {
3526
DEBUG, QUIET, INFO, WARN, ERROR, FATAL
3627
}
3728

38-
@Nullable Level getEnabled();
29+
default @Nullable Level getEnabled() {
30+
return AbstractLogger.getEnabledImpl();
31+
}
3932

40-
void setEnabled(@Nullable Level level);
33+
default void setEnabled(@Nullable Level level) {
34+
AbstractLogger.setEnabledImpl(level);
35+
}
4136

4237
default boolean isEnabled(Level level) {
43-
Level enabled = this.getEnabled();
44-
return enabled != null && level.compareTo(enabled) >= 0;
38+
return AbstractLogger.isEnabledImpl(level);
4539
}
4640

4741
/* INDENTATIONS */
4842

49-
byte push();
50-
51-
byte pop();
43+
default byte push() {
44+
return AbstractLogger.pushImpl();
45+
}
5246

53-
byte pop(byte indent);
47+
default byte pop() {
48+
return AbstractLogger.popImpl();
49+
}
5450

55-
String getIndentation();
51+
default byte pop(byte indent) {
52+
return AbstractLogger.popImpl(indent);
53+
}
5654

5755
/* CAPTURING */
5856

@@ -62,38 +60,37 @@ default boolean isEnabled(Level level) {
6260
* @return The capturing state of the Log
6361
* @see #capture()
6462
*/
65-
boolean isCapturing();
63+
default boolean isCapturing() {
64+
return AbstractLogger.isCapturingImpl();
65+
}
6666

6767
/**
6868
* Begins capturing log messages.
6969
* <p>When capturing, all log messages are stored in memory and not printed to the screen. They can either be
7070
* {@linkplain #release() released} to be printed on the screen or {@linkplain #drop() dropped} to be removed and
7171
* never printed.</p>
7272
*/
73-
void capture();
73+
default void capture() {
74+
AbstractLogger.captureImpl();
75+
}
7476

7577
/**
7678
* Drops all captured log messages and stops capturing.
7779
*
7880
* @see #capture()
7981
*/
80-
void drop();
81-
82-
/**
83-
* Releases all captured log messages (using {@link #log(Level, Object)}), then stops capturing.
84-
*
85-
* @see #capture()
86-
* @see #release(BiConsumer)
87-
*/
88-
void release();
82+
default void drop() {
83+
AbstractLogger.dropImpl();
84+
}
8985

9086
/**
91-
* Releases all captured log messages into the given consumer, then stops capturing.
87+
* Releases all captured log messages by printing them to console, then stops capturing.
9288
*
93-
* @param consumer The consumer to release the captured log messages to
9489
* @see #capture()
9590
*/
96-
void release(BiConsumer<Level, String> consumer);
91+
default void release() {
92+
AbstractLogger.releaseImpl();
93+
}
9794

9895
/* LOGGING */
9996

0 commit comments

Comments
 (0)