unify all TtlWrapper implementation to extend interface

- TtlRunnable
- TtlCallable
- ExecutorTtlWrapper
- DisableInheritableThreadFactory
- DisableInheritableForkJoinWorkerThreadFactory

src/main/java/com/alibaba/ttl/TtlCallable.java

@@ -3,6 +3,7 @@ package com.alibaba.ttl;
 import com.alibaba.ttl.spi.TtlAttachments;
 import com.alibaba.ttl.spi.TtlAttachmentsDelegate;
 import com.alibaba.ttl.spi.TtlEnhanced;
+import com.alibaba.ttl.spi.TtlWrapper;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 
@@ -35,7 +36,7 @@ import static com.alibaba.ttl.TransmittableThreadLocal.Transmitter.*;
  * @see java.util.concurrent.ExecutorCompletionService
  * @since 0.9.0
  */
-public final class TtlCallable<V> implements Callable<V>, TtlEnhanced, TtlAttachments {
+public final class TtlCallable<V> implements Callable<V>, TtlWrapper<Callable<V>>, TtlEnhanced, TtlAttachments {
     private final AtomicReference<Object> capturedRef;
     private final Callable<V> callable;
     private final boolean releaseTtlValueReferenceAfterCall;
@@ -64,8 +65,23 @@ public final class TtlCallable<V> implements Callable<V>, TtlEnhanced, TtlAttach
         }
     }
 
+    /**
+     * return the original/underneath {@link Callable}.
+     */
     @NonNull
     public Callable<V> getCallable() {
+        return unwrap();
+    }
+
+    /**
+     * unwrap to the original/underneath {@link Callable}.
+     *
+     * @see TtlWrappers#unwrap(Object)
+     * @since 2.11.4
+     */
+    @NonNull
+    @Override
+    public Callable<V> unwrap() {
         return callable;
     }
 

src/main/java/com/alibaba/ttl/TtlRunnable.java

@@ -3,6 +3,7 @@ package com.alibaba.ttl;
 import com.alibaba.ttl.spi.TtlAttachments;
 import com.alibaba.ttl.spi.TtlAttachmentsDelegate;
 import com.alibaba.ttl.spi.TtlEnhanced;
+import com.alibaba.ttl.spi.TtlWrapper;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 
@@ -32,7 +33,7 @@ import static com.alibaba.ttl.TransmittableThreadLocal.Transmitter.*;
  * @see java.util.concurrent.Executors
  * @since 0.9.0
  */
-public final class TtlRunnable implements Runnable, TtlEnhanced, TtlAttachments {
+public final class TtlRunnable implements Runnable, TtlWrapper<Runnable>, TtlEnhanced, TtlAttachments {
     private final AtomicReference<Object> capturedRef;
     private final Runnable runnable;
     private final boolean releaseTtlValueReferenceAfterRun;
@@ -66,6 +67,18 @@ public final class TtlRunnable implements Runnable, TtlEnhanced, TtlAttachments
      */
     @NonNull
     public Runnable getRunnable() {
+        return unwrap();
+    }
+
+    /**
+     * unwrap to original/unwrapped {@link Runnable}.
+     *
+     * @see TtlWrappers#unwrap(Object)
+     * @since 2.11.4
+     */
+    @NonNull
+    @Override
+    public Runnable unwrap() {
         return runnable;
     }
 

src/main/java/com/alibaba/ttl/TtlTimerTask.java

 package com.alibaba.ttl;
 
 import com.alibaba.ttl.spi.TtlEnhanced;
+import com.alibaba.ttl.spi.TtlWrapper;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 
@@ -28,7 +29,7 @@ import static com.alibaba.ttl.TransmittableThreadLocal.Transmitter.*;
  * @deprecated Use {@link TtlRunnable}, {@link java.util.concurrent.ScheduledExecutorService} instead of {@link java.util.Timer}, {@link java.util.TimerTask}.
  */
 @Deprecated
-public final class TtlTimerTask extends TimerTask implements TtlEnhanced {
+public final class TtlTimerTask extends TimerTask implements TtlWrapper<TimerTask>, TtlEnhanced {
     private final AtomicReference<Object> capturedRef;
     private final TimerTask timerTask;
     private final boolean releaseTtlValueReferenceAfterRun;
@@ -63,8 +64,23 @@ public final class TtlTimerTask extends TimerTask implements TtlEnhanced {
         return super.cancel();
     }
 
+    /**
+     * return original/unwrapped {@link TimerTask}.
+     */
     @NonNull
     public TimerTask getTimerTask() {
+        return unwrap();
+    }
+
+    /**
+     * unwrap to original/unwrapped {@link TimerTask}.
+     *
+     * @see TtlWrappers#unwrap(Object)
+     * @since 2.11.4
+     */
+    @NonNull
+    @Override
+    public TimerTask unwrap() {
         return timerTask;
     }
 

src/main/java/com/alibaba/ttl/TtlWrappers.java

 package com.alibaba.ttl;
 
 import com.alibaba.ttl.spi.TtlEnhanced;
+import com.alibaba.ttl.spi.TtlWrapper;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 
@@ -10,12 +11,13 @@ import java.util.function.*;
 import static com.alibaba.ttl.TransmittableThreadLocal.Transmitter.*;
 
 /**
- * Util methods for TTL Wrapper for common {@code Functional Interface}.
+ * Util methods for TTL Wrapper:
+ * wrap common {@code Functional Interface}, unwrap TTL Wrapper and check TTL Wrapper.
  * <p>
  * <b><i>Note:</i></b>
  * <ul>
- * <li>all method is {@code null}-safe, when input parameter is {@code null}, return {@code null}.</li>
- * <li>skip wrap (aka. just return input parameter), when input parameter is already wrapped.</li>
+ * <li>all methods is {@code null}-safe, when input parameter is {@code null}, return {@code null}.</li>
+ * <li>all wrap method skip wrap (aka. just return input parameter), when input parameter is already wrapped.</li>
  * </ul>
  *
  * @author Jerry Lee (oldratlee at gmail dot com)
@@ -25,6 +27,7 @@ import static com.alibaba.ttl.TransmittableThreadLocal.Transmitter.*;
  * @see TtlCallable
  * @see TtlCallable#get(Callable)
  * @see TtlCallable#unwrap(Callable)
+ * @see TtlWrapper
  * @since 2.11.4
  */
 public class TtlWrappers {
@@ -42,7 +45,7 @@ public class TtlWrappers {
         else return new TtlSupplier<T>(supplier);
     }
 
-    private static class TtlSupplier<T> implements Supplier<T>, TtlEnhanced {
+    private static class TtlSupplier<T> implements Supplier<T>, TtlWrapper<Supplier<T>>, TtlEnhanced {
         final Supplier<T> supplier;
         final Object capture;
 
@@ -60,23 +63,12 @@ public class TtlWrappers {
                 restore(backup);
             }
         }
-    }
 
-    /**
-     * Unwrap {@code TtlSupplier} to the original/underneath one.
-     * <p>
-     * this method is {@code null}-safe, when input {@code Supplier} parameter is {@code null}, return {@code null};
-     * if input {@code Supplier} parameter is not a {@code Supplier} just return input {@code Supplier}.
-     * <p>
-     * so {@code unwrap(Supplier)} will always return the same input {@code Supplier} object.
-     *
-     * @see #wrap(Supplier)
-     * @since 2.11.4
-     */
-    @Nullable
-    public static <T> Supplier<T> unwrap(@Nullable Supplier<T> supplier) {
-        if (!(supplier instanceof TtlSupplier)) return supplier;
-        else return ((TtlSupplier<T>) supplier).supplier;
+        @NonNull
+        @Override
+        public Supplier<T> unwrap() {
+            return supplier;
+        }
     }
 
     /**
@@ -93,7 +85,7 @@ public class TtlWrappers {
         else return new TtlConsumer<T>(consumer);
     }
 
-    private static class TtlConsumer<T> implements Consumer<T>, TtlEnhanced {
+    private static class TtlConsumer<T> implements Consumer<T>, TtlWrapper<Consumer<T>>, TtlEnhanced {
         final Consumer<T> consumer;
         final Object capture;
 
@@ -111,25 +103,15 @@ public class TtlWrappers {
                 restore(backup);
             }
         }
-    }
 
-    /**
-     * Unwrap {@code TtlConsumer} to the original/underneath one.
-     * <p>
-     * this method is {@code null}-safe, when input {@code Consumer} parameter is {@code null}, return {@code null};
-     * if input {@code Consumer} parameter is not a {@code Consumer} just return input {@code Consumer}.
-     * <p>
-     * so {@code unwrap(Consumer)} will always return the same input {@code Consumer} object.
-     *
-     * @see #wrap(Consumer)
-     * @since 2.11.4
-     */
-    @Nullable
-    public static <T> Consumer<T> unwrap(@Nullable Consumer<T> consumer) {
-        if (!(consumer instanceof TtlConsumer)) return consumer;
-        else return ((TtlConsumer<T>) consumer).consumer;
+        @NonNull
+        @Override
+        public Consumer<T> unwrap() {
+            return consumer;
+        }
     }
 
+
     /**
      * wrap input {@link BiConsumer} to TTL wrapper.
      *
@@ -144,7 +126,7 @@ public class TtlWrappers {
         else return new TtlBiConsumer<T, U>(consumer);
     }
 
-    private static class TtlBiConsumer<T, U> implements BiConsumer<T, U>, TtlEnhanced {
+    private static class TtlBiConsumer<T, U> implements BiConsumer<T, U>, TtlWrapper<BiConsumer<T, U>>, TtlEnhanced {
         final BiConsumer<T, U> consumer;
         final Object capture;
 
@@ -162,23 +144,12 @@ public class TtlWrappers {
                 restore(backup);
             }
         }
-    }
 
-    /**
-     * Unwrap {@code TtlBiConsumer} to the original/underneath one.
-     * <p>
-     * this method is {@code null}-safe, when input {@code BiConsumer} parameter is {@code null}, return {@code null};
-     * if input {@code BiConsumer} parameter is not a {@code BiConsumer} just return input {@code BiConsumer}.
-     * <p>
-     * so {@code unwrap(BiConsumer)} will always return the same input {@code BiConsumer} object.
-     *
-     * @see #wrap(BiConsumer)
-     * @since 2.11.4
-     */
-    @Nullable
-    public static <T, U> BiConsumer<T, U> unwrap(@Nullable BiConsumer<T, U> consumer) {
-        if (!(consumer instanceof TtlBiConsumer)) return consumer;
-        else return ((TtlBiConsumer<T, U>) consumer).consumer;
+        @NonNull
+        @Override
+        public BiConsumer<T, U> unwrap() {
+            return consumer;
+        }
     }
 
     /**
@@ -195,7 +166,7 @@ public class TtlWrappers {
         else return new TtlFunction<T, R>(fn);
     }
 
-    private static class TtlFunction<T, R> implements Function<T, R>, TtlEnhanced {
+    private static class TtlFunction<T, R> implements Function<T, R>, TtlWrapper<Function<T, R>>, TtlEnhanced {
         final Function<T, R> fn;
         final Object capture;
 
@@ -213,25 +184,15 @@ public class TtlWrappers {
                 restore(backup);
             }
         }
-    }
 
-    /**
-     * Unwrap {@code TtlFunction} to the original/underneath one.
-     * <p>
-     * this method is {@code null}-safe, when input {@code Function} parameter is {@code null}, return {@code null};
-     * if input {@code Function} parameter is not a {@code TtlFunction} just return input {@code Function}.
-     * <p>
-     * so {@code unwrap(Function)} will always return the same input {@code Function} object.
-     *
-     * @see #wrap(Function)
-     * @since 2.11.4
-     */
-    @Nullable
-    public static <T, R> Function<T, R> unwrap(@Nullable Function<T, R> fn) {
-        if (!(fn instanceof TtlFunction)) return fn;
-        else return ((TtlFunction<T, R>) fn).fn;
+        @NonNull
+        @Override
+        public Function<T, R> unwrap() {
+            return fn;
+        }
     }
 
+
     /**
      * wrap input {@link BiFunction} to TTL wrapper.
      *
@@ -246,7 +207,7 @@ public class TtlWrappers {
         else return new TtlBiFunction<T, U, R>(fn);
     }
 
-    private static class TtlBiFunction<T, U, R> implements BiFunction<T, U, R>, TtlEnhanced {
+    private static class TtlBiFunction<T, U, R> implements BiFunction<T, U, R>, TtlWrapper<BiFunction<T, U, R>>, TtlEnhanced {
         final BiFunction<T, U, R> fn;
         final Object capture;
 
@@ -264,23 +225,43 @@ public class TtlWrappers {
                 restore(backup);
             }
         }
+
+        @NonNull
+        @Override
+        public BiFunction<T, U, R> unwrap() {
+            return fn;
+        }
     }
 
     /**
-     * Unwrap {@code TtlBiFunction} to the original/underneath one.
+     * Generic unwrap method, unwrap {@code TtlWrapper} to the original/underneath one.
      * <p>
      * this method is {@code null}-safe, when input {@code BiFunction} parameter is {@code null}, return {@code null};
-     * if input {@code BiFunction} parameter is not a {@code TtlBiFunction} just return input {@code BiFunction}.
+     * if input parameter is not a {@code TtlWrapper} just return input.
      * <p>
-     * so {@code unwrap(BiFunction)} will always return the same input {@code BiFunction} object.
+     * so {@code unwrap} will always return the same input object.
      *
-     * @see #wrap(BiFunction)
+     * @see TtlRunnable#unwrap(Runnable)
+     * @see TtlCallable#unwrap(Callable)
+     * @see com.alibaba.ttl.threadpool.TtlExecutors#unwrap(java.util.concurrent.Executor)
+     * @see com.alibaba.ttl.threadpool.TtlExecutors#unwrap(java.util.concurrent.ThreadFactory)
+     * @see com.alibaba.ttl.threadpool.TtlForkJoinPoolHelper#unwrap(java.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory)
      * @since 2.11.4
      */
     @Nullable
-    public static <T, U, R> BiFunction<T, U, R> unwrap(@Nullable BiFunction<T, U, R> fn) {
-        if (!(fn instanceof TtlBiFunction)) return fn;
-        else return ((TtlBiFunction<T, U, R>) fn).fn;
+    @SuppressWarnings("unchecked")
+    public static <T> T unwrap(@Nullable T obj) {
+        if (!isWrapper(obj)) return obj;
+        else return ((TtlWrapper<T>) obj).unwrap();
+    }
+
+    /**
+     * check the input object is {@code TtlWrapper} or not.
+     *
+     * @since 2.11.4
+     */
+    public static <T> boolean isWrapper(@Nullable T obj) {
+        return obj instanceof TtlWrapper;
     }
 
     private TtlWrappers() {

src/main/java/com/alibaba/ttl/spi/TtlWrapper.java

+package com.alibaba.ttl.spi;
+
+import com.alibaba.ttl.TtlWrappers;
+import edu.umd.cs.findbugs.annotations.NonNull;
+
+/**
+ * Ttl Wrapper interface.
+ *
+ * @author Jerry Lee (oldratlee at gmail dot com)
+ * @see TtlWrappers#unwrap
+ * @since 2.11.4
+ */
+public interface TtlWrapper<T> extends TtlEnhanced {
+    /**
+     * unwrap {@link TtlWrapper} to the original/underneath one.
+     * <p>
+     * this method is {@code null}-safe, when input {@code BiFunction} parameter is {@code null}, return {@code null};
+     * if input parameter is not a {@code TtlWrapper} just return input.
+     * <p>
+     * so {@code unwrap} will always return the same input object.
+     *
+     * @see TtlWrappers#unwrap(Object)
+     */
+    @NonNull
+    T unwrap();
+}

src/main/java/com/alibaba/ttl/threadpool/DisableInheritableForkJoinWorkerThreadFactory.java

 package com.alibaba.ttl.threadpool;
 
+import com.alibaba.ttl.spi.TtlWrapper;
 import edu.umd.cs.findbugs.annotations.NonNull;
 
 import java.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory;
@@ -10,7 +11,7 @@ import java.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory;
  * @author Jerry Lee (oldratlee at gmail dot com)
  * @since 2.10.1
  */
-public interface DisableInheritableForkJoinWorkerThreadFactory extends ForkJoinWorkerThreadFactory {
+public interface DisableInheritableForkJoinWorkerThreadFactory extends ForkJoinWorkerThreadFactory, TtlWrapper<ForkJoinWorkerThreadFactory> {
     /**
      * Unwrap {@link DisableInheritableThreadFactory} to the original/underneath one.
      */

src/main/java/com/alibaba/ttl/threadpool/DisableInheritableThreadFactory.java

 package com.alibaba.ttl.threadpool;
 
+import com.alibaba.ttl.spi.TtlWrapper;
 import edu.umd.cs.findbugs.annotations.NonNull;
 
 import java.util.concurrent.ThreadFactory;
@@ -11,7 +12,7 @@ import java.util.concurrent.ThreadFactory;
  * @see ThreadFactory
  * @since 2.10.0
  */
-public interface DisableInheritableThreadFactory extends ThreadFactory {
+public interface DisableInheritableThreadFactory extends ThreadFactory, TtlWrapper<ThreadFactory> {
     /**
      * Unwrap {@link DisableInheritableThreadFactory} to the original/underneath one.
      */

src/main/java/com/alibaba/ttl/threadpool/ExecutorTtlWrapper.java

@@ -3,6 +3,7 @@ package com.alibaba.ttl.threadpool;
 import com.alibaba.ttl.TransmittableThreadLocal;
 import com.alibaba.ttl.TtlRunnable;
 import com.alibaba.ttl.spi.TtlEnhanced;
+import com.alibaba.ttl.spi.TtlWrapper;
 import edu.umd.cs.findbugs.annotations.NonNull;
 
 import java.util.concurrent.Executor;
@@ -15,7 +16,7 @@ import java.util.concurrent.Executor;
  * @author Jerry Lee (oldratlee at gmail dot com)
  * @since 0.9.0
  */
-class ExecutorTtlWrapper implements Executor, TtlEnhanced {
+class ExecutorTtlWrapper implements Executor, TtlWrapper<Executor>, TtlEnhanced {
     private final Executor executor;
 
     ExecutorTtlWrapper(@NonNull Executor executor) {

src/main/java/com/alibaba/ttl/threadpool/TtlForkJoinPoolHelper.java

@@ -46,7 +46,7 @@ public class TtlForkJoinPoolHelper {
     }
 
     /**
-     * check the {@link ForkJoinWorkerThreadFactory} is  {@link DisableInheritableForkJoinWorkerThreadFactory} or not.
+     * check the {@link ForkJoinWorkerThreadFactory} is {@link DisableInheritableForkJoinWorkerThreadFactory} or not.
      *
      * @see DisableInheritableForkJoinWorkerThreadFactory
      * @since 2.10.1