clean up TL a bit

PorkStudios · Feb 27, 2021 · c836109 · c836109
1 parent c9f385e
commit c836109
Show file tree

Hide file tree

Showing 13 changed files with 134 additions and 73 deletions.
diff --git a/common/src/main/java/net/daporkchop/lib/common/misc/threadfactory/AbstractThreadFactory.java b/common/src/main/java/net/daporkchop/lib/common/misc/threadfactory/AbstractThreadFactory.java
@@ -1,7 +1,7 @@
 /*
  * Adapted from The MIT License (MIT)
  *
- * Copyright (c) 2018-2020 DaPorkchop_
+ * Copyright (c) 2018-2021 DaPorkchop_
  *
  * 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,
@@ -21,6 +21,7 @@
 package net.daporkchop.lib.common.misc.threadfactory;
 
 import lombok.Getter;
+import lombok.NonNull;
 import lombok.RequiredArgsConstructor;
 import lombok.experimental.Accessors;
 
@@ -35,15 +36,16 @@
 @Getter
 @Accessors(fluent = true)
 public abstract class AbstractThreadFactory implements ThreadFactory {
+    protected final ThreadFactory delegate;
     protected final ClassLoader contextClassLoader;
     protected final Thread.UncaughtExceptionHandler uncaughtExceptionHandler;
     protected final int priority;
     protected final boolean daemon;
 
     @Override
-    public Thread newThread(Runnable task) {
+    public Thread newThread(@NonNull Runnable task) {
         Runnable wrappedTask = this.wrapTask(task);
-        Thread thread = PThreadFactories.DEFAULT_THREAD_FACTORY.newThread(wrappedTask);
+        Thread thread = this.delegate.newThread(wrappedTask);
 
         String name = this.getName(task, wrappedTask, thread);
         if (name != null) {
@@ -62,9 +64,9 @@ public Thread newThread(Runnable task) {
         return thread;
     }
 
-    protected Runnable wrapTask(Runnable task) {
+    protected Runnable wrapTask(@NonNull Runnable task) {
         return task;
     }
 
-    protected abstract String getName(Runnable task, Runnable wrappedTask, Thread thread);
+    protected abstract String getName(@NonNull Runnable task, @NonNull Runnable wrappedTask, @NonNull Thread thread);
 }
diff --git a/...et/daporkchop/lib/common/misc/threadfactory/CollapsingIncrementingNamedThreadFactory.java b/...et/daporkchop/lib/common/misc/threadfactory/CollapsingIncrementingNamedThreadFactory.java
@@ -1,7 +1,7 @@
 /*
  * Adapted from The MIT License (MIT)
  *
- * Copyright (c) 2018-2020 DaPorkchop_
+ * Copyright (c) 2018-2021 DaPorkchop_
  *
  * 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,
@@ -36,28 +36,29 @@
  * @author DaPorkchop_
  */
 @Accessors(fluent = true)
-public final class CollapsingIncrementingNamedThreadFactory extends AbstractThreadFactory {
+public class CollapsingIncrementingNamedThreadFactory extends AbstractThreadFactory {
     @Getter
     protected final String format;
     protected final BitSet usedIds = new BitSet();
 
-    public CollapsingIncrementingNamedThreadFactory(@NonNull String format, ClassLoader contextClassLoader, Thread.UncaughtExceptionHandler uncaughtExceptionHandler, int priority, boolean daemon) {
-        super(contextClassLoader, uncaughtExceptionHandler, priority, daemon);
+    public CollapsingIncrementingNamedThreadFactory(@NonNull String format, ThreadFactory delegate, ClassLoader contextClassLoader, Thread.UncaughtExceptionHandler uncaughtExceptionHandler, int priority, boolean daemon) {
+        super(delegate, contextClassLoader, uncaughtExceptionHandler, priority, daemon);
 
         this.format = format;
     }
 
     @Override
-    protected Runnable wrapTask(Runnable task) {
+    protected Runnable wrapTask(@NonNull Runnable task) {
         return new TaskWrapper(task);
     }
 
     @Override
-    protected String getName(Runnable task, Runnable wrappedTask, Thread thread) {
+    protected String getName(@NonNull Runnable task, @NonNull Runnable wrappedTask, @NonNull Thread thread) {
         return String.format(this.format, ((TaskWrapper) wrappedTask).id);
     }
 
     private final class TaskWrapper implements Runnable {
+        @NonNull
         protected final Runnable delegate;
         protected final int id;
 

diff --git a/...n/src/main/java/net/daporkchop/lib/common/misc/threadfactory/FixedNamedThreadFactory.java b/...n/src/main/java/net/daporkchop/lib/common/misc/threadfactory/FixedNamedThreadFactory.java
@@ -1,7 +1,7 @@
 /*
  * Adapted from The MIT License (MIT)
  *
- * Copyright (c) 2018-2020 DaPorkchop_
+ * Copyright (c) 2018-2021 DaPorkchop_
  *
  * 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,
@@ -33,17 +33,17 @@
  */
 @Getter
 @Accessors(fluent = true)
-public final class FixedNamedThreadFactory extends AbstractThreadFactory {
+public class FixedNamedThreadFactory extends AbstractThreadFactory {
     protected final String name;
 
-    public FixedNamedThreadFactory(@NonNull String name, ClassLoader contextClassLoader, Thread.UncaughtExceptionHandler uncaughtExceptionHandler, int priority, boolean daemon) {
-        super(contextClassLoader, uncaughtExceptionHandler, priority, daemon);
+    public FixedNamedThreadFactory(@NonNull String name, ThreadFactory delegate, ClassLoader contextClassLoader, Thread.UncaughtExceptionHandler uncaughtExceptionHandler, int priority, boolean daemon) {
+        super(delegate, contextClassLoader, uncaughtExceptionHandler, priority, daemon);
 
         this.name = name;
     }
 
     @Override
-    protected String getName(Runnable task, Runnable wrappedTask, Thread thread) {
+    protected String getName(@NonNull Runnable task, @NonNull Runnable wrappedTask, @NonNull Thread thread) {
         return this.name;
     }
 }
diff --git a/...ain/java/net/daporkchop/lib/common/misc/threadfactory/IncrementingNamedThreadFactory.java b/...ain/java/net/daporkchop/lib/common/misc/threadfactory/IncrementingNamedThreadFactory.java
@@ -1,7 +1,7 @@
 /*
  * Adapted from The MIT License (MIT)
  *
- * Copyright (c) 2018-2020 DaPorkchop_
+ * Copyright (c) 2018-2021 DaPorkchop_
  *
  * 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,
@@ -33,19 +33,19 @@
  * @author DaPorkchop_
  */
 @Accessors(fluent = true)
-public final class IncrementingNamedThreadFactory extends AbstractThreadFactory {
+public class IncrementingNamedThreadFactory extends AbstractThreadFactory {
     @Getter
     protected final String format;
     protected final AtomicInteger counter = new AtomicInteger();
 
-    public IncrementingNamedThreadFactory(@NonNull String format, ClassLoader contextClassLoader, Thread.UncaughtExceptionHandler uncaughtExceptionHandler, int priority, boolean daemon) {
-        super(contextClassLoader, uncaughtExceptionHandler, priority, daemon);
+    public IncrementingNamedThreadFactory(@NonNull String format, ThreadFactory delegate, ClassLoader contextClassLoader, Thread.UncaughtExceptionHandler uncaughtExceptionHandler, int priority, boolean daemon) {
+        super(delegate, contextClassLoader, uncaughtExceptionHandler, priority, daemon);
 
         this.format = format;
     }
 
     @Override
-    protected String getName(Runnable task, Runnable wrappedTask, Thread thread) {
+    protected String getName(@NonNull Runnable task, @NonNull Runnable wrappedTask, @NonNull Thread thread) {
         return String.format(this.format, this.counter.getAndIncrement());
     }
 }
diff --git a/common/src/main/java/net/daporkchop/lib/common/misc/threadfactory/ThreadFactoryBuilder.java b/common/src/main/java/net/daporkchop/lib/common/misc/threadfactory/ThreadFactoryBuilder.java
@@ -1,7 +1,7 @@
 /*
  * Adapted from The MIT License (MIT)
  *
- * Copyright (c) 2018-2020 DaPorkchop_
+ * Copyright (c) 2018-2021 DaPorkchop_
  *
  * 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,
@@ -21,6 +21,7 @@
 package net.daporkchop.lib.common.misc.threadfactory;
 
 import lombok.NoArgsConstructor;
+import lombok.NonNull;
 import lombok.Setter;
 import lombok.experimental.Accessors;
 
@@ -34,12 +35,14 @@
  * @author DaPorkchop_
  * @see PThreadFactories#builder()
  */
-@NoArgsConstructor(onConstructor_ = {@Deprecated})
+@NoArgsConstructor(onConstructor_ = { @Deprecated })
 @Setter
 @Accessors(fluent = true, chain = true)
 public class ThreadFactoryBuilder {
     protected String name;
 
+    @NonNull
+    protected ThreadFactory delegate = PThreadFactories.DEFAULT_THREAD_FACTORY;
     protected ClassLoader contextClassLoader;
     protected Thread.UncaughtExceptionHandler uncaughtExceptionHandler;
     protected int priority = Thread.NORM_PRIORITY;
@@ -105,19 +108,19 @@ public ThreadFactory build() {
         if (!this.formatId) {
             if (this.name == null) {
                 if (this.contextClassLoader == null && this.uncaughtExceptionHandler == null && this.priority == Thread.NORM_PRIORITY && !this.daemon) {
-                    return PThreadFactories.DEFAULT_THREAD_FACTORY;
+                    return this.delegate;
                 } else {
-                    return new UnnamedThreadFactory(this.contextClassLoader, this.uncaughtExceptionHandler, this.priority, this.daemon);
+                    return new UnnamedThreadFactory(this.delegate, this.contextClassLoader, this.uncaughtExceptionHandler, this.priority, this.daemon);
                 }
             } else {
-                return new FixedNamedThreadFactory(this.name, this.contextClassLoader, this.uncaughtExceptionHandler, this.priority, this.daemon);
+                return new FixedNamedThreadFactory(this.name, this.delegate, this.contextClassLoader, this.uncaughtExceptionHandler, this.priority, this.daemon);
             }
         } else if (this.name == null) {
             throw new IllegalStateException("formatId is set, but no name is given!");
         } else if (this.collapsingId) {
-            return new CollapsingIncrementingNamedThreadFactory(this.name, this.contextClassLoader, this.uncaughtExceptionHandler, this.priority, this.daemon);
+            return new CollapsingIncrementingNamedThreadFactory(this.name, this.delegate, this.contextClassLoader, this.uncaughtExceptionHandler, this.priority, this.daemon);
         } else {
-            return new IncrementingNamedThreadFactory(this.name, this.contextClassLoader, this.uncaughtExceptionHandler, this.priority, this.daemon);
+            return new IncrementingNamedThreadFactory(this.name, this.delegate, this.contextClassLoader, this.uncaughtExceptionHandler, this.priority, this.daemon);
         }
     }
 }
diff --git a/common/src/main/java/net/daporkchop/lib/common/misc/threadfactory/UnnamedThreadFactory.java b/common/src/main/java/net/daporkchop/lib/common/misc/threadfactory/UnnamedThreadFactory.java
@@ -1,7 +1,7 @@
 /*
  * Adapted from The MIT License (MIT)
  *
- * Copyright (c) 2018-2020 DaPorkchop_
+ * Copyright (c) 2018-2021 DaPorkchop_
  *
  * 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,
@@ -20,20 +20,22 @@
 
 package net.daporkchop.lib.common.misc.threadfactory;
 
+import lombok.NonNull;
+
 import java.util.concurrent.ThreadFactory;
 
 /**
  * A {@link ThreadFactory} that does not apply any names to created threads.
  *
  * @author DaPorkchop_
  */
-public final class UnnamedThreadFactory extends AbstractThreadFactory {
-    public UnnamedThreadFactory(ClassLoader contextClassLoader, Thread.UncaughtExceptionHandler uncaughtExceptionHandler, int priority, boolean daemon) {
-        super(contextClassLoader, uncaughtExceptionHandler, priority, daemon);
+public class UnnamedThreadFactory extends AbstractThreadFactory {
+    public UnnamedThreadFactory(ThreadFactory delegate, ClassLoader contextClassLoader, Thread.UncaughtExceptionHandler uncaughtExceptionHandler, int priority, boolean daemon) {
+        super(delegate, contextClassLoader, uncaughtExceptionHandler, priority, daemon);
     }
 
     @Override
-    protected String getName(Runnable task, Runnable wrappedTask, Thread thread) {
+    protected String getName(@NonNull Runnable task, @NonNull Runnable wrappedTask, @NonNull Thread thread) {
         return null;
     }
 }
diff --git a/common/src/main/java/net/daporkchop/lib/common/misc/threadlocal/JavaTL.java b/common/src/main/java/net/daporkchop/lib/common/misc/threadlocal/JavaTL.java
@@ -1,7 +1,7 @@
 /*
  * Adapted from The MIT License (MIT)
  *
- * Copyright (c) 2018-2020 DaPorkchop_
+ * Copyright (c) 2018-2021 DaPorkchop_
  *
  * 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,
@@ -20,7 +20,10 @@
 
 package net.daporkchop.lib.common.misc.threadlocal;
 
+import lombok.Getter;
+import lombok.NonNull;
 import lombok.RequiredArgsConstructor;
+import lombok.experimental.Accessors;
 
 import java.util.function.Supplier;
 
@@ -29,12 +32,32 @@
  *
  * @author DaPorkchop_
  */
-@RequiredArgsConstructor
-final class JavaTL<T> extends ThreadLocal<T> implements TL<T> {
-    protected final Supplier<T> initialSupplier;
+public class JavaTL<T> extends ThreadLocal<T> implements TL<T> {
+    /**
+     * Extension of {@link JavaTL} with a fixed default initialization value.
+     *
+     * @author DaPorkchop_
+     */
+    @RequiredArgsConstructor
+    @Getter
+    @Accessors(fluent = true)
+    public static class WithConstant<T> extends JavaTL<T> {
+        protected final T initialValue;
+    }
+
+    /**
+     * Extension of {@link JavaTL} which computes the default initialization value on-demand.
+     *
+     * @author DaPorkchop_
+     */
+    @RequiredArgsConstructor
+    public static class WithInitializer<T> extends JavaTL<T> {
+        @NonNull
+        protected final Supplier<T> initialSupplier;
 
-    @Override
-    protected T initialValue() {
-        return this.initialSupplier != null ? this.initialSupplier.get() : null;
+        @Override
+        protected T initialValue() {
+            return this.initialSupplier.get();
+        }
     }
 }
diff --git a/...p/lib/common/misc/threadlocal/FastTL.java → .../common/misc/threadlocal/NettyFastTL.java b/...p/lib/common/misc/threadlocal/FastTL.java → .../common/misc/threadlocal/NettyFastTL.java
@@ -1,7 +1,7 @@
 /*
  * Adapted from The MIT License (MIT)
  *
- * Copyright (c) 2018-2020 DaPorkchop_
+ * Copyright (c) 2018-2021 DaPorkchop_
  *
  * 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,
@@ -21,7 +21,10 @@
 package net.daporkchop.lib.common.misc.threadlocal;
 
 import io.netty.util.concurrent.FastThreadLocal;
+import lombok.Getter;
+import lombok.NonNull;
 import lombok.RequiredArgsConstructor;
+import lombok.experimental.Accessors;
 
 import java.util.function.Supplier;
 
@@ -31,11 +34,32 @@
  * @author DaPorkchop_
  */
 @RequiredArgsConstructor
-final class FastTL<T> extends FastThreadLocal<T> implements TL<T> {
-    protected final Supplier<T> initialSupplier;
+public class NettyFastTL<T> extends FastThreadLocal<T> implements TL<T> {
+    /**
+     * Extension of {@link NettyFastTL} with a fixed default initialization value.
+     *
+     * @author DaPorkchop_
+     */
+    @RequiredArgsConstructor
+    @Getter
+    @Accessors(fluent = true)
+    public static class WithConstant<T> extends NettyFastTL<T> {
+        protected final T initialValue;
+    }
+
+    /**
+     * Extension of {@link NettyFastTL} which computes the default initialization value on-demand.
+     *
+     * @author DaPorkchop_
+     */
+    @RequiredArgsConstructor
+    public static class WithInitializer<T> extends NettyFastTL<T> {
+        @NonNull
+        protected final Supplier<T> initialSupplier;
 
-    @Override
-    protected T initialValue() {
-        return this.initialSupplier != null ? this.initialSupplier.get() : null;
+        @Override
+        protected T initialValue() {
+            return this.initialSupplier.get();
+        }
     }
 }