split util methods from TtlWrappers to TtlUnwrap/TtlWrappers

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

@@ -76,7 +76,7 @@ public final class TtlCallable<V> implements Callable<V>, TtlWrapper<Callable<V>
     /**
      * unwrap to the original/underneath {@link Callable}.
      *
-     * @see TtlWrappers#unwrap(Object)
+     * @see TtlUnwrap#unwrap(Object)
      * @since 2.11.4
      */
     @NonNull

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

@@ -73,7 +73,7 @@ public final class TtlRunnable implements Runnable, TtlWrapper<Runnable>, TtlEnh
     /**
      * unwrap to original/unwrapped {@link Runnable}.
      *
-     * @see TtlWrappers#unwrap(Object)
+     * @see TtlUnwrap#unwrap(Object)
      * @since 2.11.4
      */
     @NonNull

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

@@ -75,7 +75,7 @@ public final class TtlTimerTask extends TimerTask implements TtlWrapper<TimerTas
     /**
      * unwrap to original/unwrapped {@link TimerTask}.
      *
-     * @see TtlWrappers#unwrap(Object)
+     * @see TtlUnwrap#unwrap(Object)
      * @since 2.11.4
      */
     @NonNull

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

+package com.alibaba.ttl;
+
+import com.alibaba.ttl.spi.TtlWrapper;
+import edu.umd.cs.findbugs.annotations.Nullable;
+
+import java.util.concurrent.Callable;
+
+/**
+ * Util methods for TTL Wrapper: unwrap TTL Wrapper and check TTL Wrapper.
+ * <p>
+ * <b><i>Note:</i></b>
+ * all methods is {@code null}-safe, when input parameter is {@code null}, return {@code null}.
+ * <p>
+ * <b><i>Implementation Note:</i></b>
+ * The util methods in this class should have been inside {@link TtlWrappers}.<br>
+ * But for {@code Java 6} support, it's required splitting the util methods
+ * which involved {@code Java 8} from {@link TtlWrappers}.
+ * In order to avoid loading {@code Java 8} class (eg: {@link java.util.function.Consumer}, {@link java.util.function.Supplier}),
+ * when invoking any methods of {@link TtlWrappers}.
+ *
+ * @author Jerry Lee (oldratlee at gmail dot com)
+ * @see TtlWrappers
+ * @see TtlWrapper
+ * @see TtlRunnable
+ * @see TtlCallable
+ * @since 2.11.4
+ */
+public class TtlUnwrap {
+    /**
+     * 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 parameter is not a {@code TtlWrapper} just return input.
+     * <p>
+     * so {@code unwrap} will always return the same input object.
+     *
+     * @see TtlWrappers#wrap(java.util.function.Supplier)
+     * @see TtlWrappers#wrap(java.util.function.Consumer)
+     * @see TtlWrappers#wrap(java.util.function.BiConsumer)
+     * @see TtlWrappers#wrap(java.util.function.Function)
+     * @see TtlWrappers#wrap(java.util.function.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
+    @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 a {@code TtlWrapper} or not.
+     *
+     * @since 2.11.4
+     */
+    public static <T> boolean isWrapper(@Nullable T obj) {
+        return obj instanceof TtlWrapper;
+    }
+
+    private TtlUnwrap() {
+        throw new InstantiationError("Must not instantiate this class");
+    }
+}

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

@@ -5,14 +5,12 @@ import com.alibaba.ttl.spi.TtlWrapper;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 
-import java.util.concurrent.Callable;
 import java.util.function.*;
 
 import static com.alibaba.ttl.TransmittableThreadLocal.Transmitter.*;
 
 /**
- * Util methods for TTL Wrapper:
- * wrap common {@code Functional Interface}, unwrap TTL Wrapper and check TTL Wrapper.
+ * Util methods for TTL Wrapper: wrap common {@code Functional Interface}.
  * <p>
  * <b><i>Note:</i></b>
  * <ul>
@@ -22,11 +20,8 @@ import static com.alibaba.ttl.TransmittableThreadLocal.Transmitter.*;
  *
  * @author Jerry Lee (oldratlee at gmail dot com)
  * @see TtlRunnable
- * @see TtlRunnable#get(Runnable)
- * @see TtlRunnable#unwrap(Runnable)
  * @see TtlCallable
- * @see TtlCallable#get(Callable)
- * @see TtlCallable#unwrap(Callable)
+ * @see TtlUnwrap
  * @see TtlWrapper
  * @since 2.11.4
  */
@@ -36,6 +31,7 @@ public class TtlWrappers {
      *
      * @param supplier input {@link Supplier}
      * @return Wrapped {@link Supplier}
+     * @see TtlUnwrap#unwrap(Object)
      * @since 2.11.4
      */
     @Nullable
@@ -76,6 +72,7 @@ public class TtlWrappers {
      *
      * @param consumer input {@link Consumer}
      * @return Wrapped {@link Consumer}
+     * @see TtlUnwrap#unwrap(Object)
      * @since 2.11.4
      */
     @Nullable
@@ -117,6 +114,7 @@ public class TtlWrappers {
      *
      * @param consumer input {@link BiConsumer}
      * @return Wrapped {@link BiConsumer}
+     * @see TtlUnwrap#unwrap(Object)
      * @since 2.11.4
      */
     @Nullable
@@ -157,6 +155,7 @@ public class TtlWrappers {
      *
      * @param fn input {@link Function}
      * @return Wrapped {@link Function}
+     * @see TtlUnwrap#unwrap(Object)
      * @since 2.11.4
      */
     @Nullable
@@ -198,6 +197,7 @@ public class TtlWrappers {
      *
      * @param fn input {@link BiFunction}
      * @return Wrapped {@link BiFunction}
+     * @see TtlUnwrap#unwrap(Object)
      * @since 2.11.4
      */
     @Nullable
@@ -233,37 +233,6 @@ public class TtlWrappers {
         }
     }
 
-    /**
-     * 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 parameter is not a {@code TtlWrapper} just return input.
-     * <p>
-     * so {@code unwrap} will always return the same input object.
-     *
-     * @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
-    @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() {
         throw new InstantiationError("Must not instantiate this class");
     }

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

 package com.alibaba.ttl.spi;
 
-import com.alibaba.ttl.TtlWrappers;
+import com.alibaba.ttl.TtlUnwrap;
 import edu.umd.cs.findbugs.annotations.NonNull;
 
 /**
  * Ttl Wrapper interface.
  *
  * @author Jerry Lee (oldratlee at gmail dot com)
- * @see TtlWrappers#unwrap
+ * @see TtlUnwrap#unwrap
  * @since 2.11.4
  */
 public interface TtlWrapper<T> extends TtlEnhanced {
@@ -19,7 +19,7 @@ public interface TtlWrapper<T> extends TtlEnhanced {
      * <p>
      * so {@code unwrap} will always return the same input object.
      *
-     * @see TtlWrappers#unwrap(Object)
+     * @see TtlUnwrap#unwrap(Object)
      */
     @NonNull
     T unwrap();

src/test/java/com/alibaba/ttl/TtlCallableTest.kt

@@ -172,8 +172,8 @@ class TtlCallableTest {
         assertSame(callable, TtlCallable.unwrap(callable))
         assertSame(callable, TtlCallable.unwrap(ttlCallable))
 
-        assertSame(callable, TtlWrappers.unwrap(callable))
-        assertSame(callable, TtlWrappers.unwrap(ttlCallable))
+        assertSame(callable, TtlUnwrap.unwrap(callable))
+        assertSame(callable, TtlUnwrap.unwrap(ttlCallable))
 
 
         assertEquals(listOf(callable), TtlCallable.unwraps(listOf(callable)))

src/test/java/com/alibaba/ttl/TtlRunnableTest.kt

@@ -298,8 +298,8 @@ class TtlRunnableTest {
         assertSame(runnable, TtlRunnable.unwrap(runnable))
         assertSame(runnable, TtlRunnable.unwrap(ttlRunnable))
 
-        assertSame(runnable, TtlWrappers.unwrap(runnable))
-        assertSame(runnable, TtlWrappers.unwrap(ttlRunnable))
+        assertSame(runnable, TtlUnwrap.unwrap(runnable))
+        assertSame(runnable, TtlUnwrap.unwrap(ttlRunnable))
 
 
         assertEquals(listOf(runnable), TtlRunnable.unwraps(listOf(runnable)))

src/test/java/com/alibaba/ttl/TtlWrappersTest.kt

@@ -3,6 +3,8 @@ package com.alibaba.ttl
 import com.alibaba.expandThreadPool
 import com.alibaba.support.junit.conditional.BelowJava8
 import com.alibaba.support.junit.conditional.ConditionalIgnoreRule
+import com.alibaba.ttl.TtlUnwrap.unwrap
+import com.alibaba.ttl.TtlWrappers.wrap
 import org.junit.AfterClass
 import org.junit.Assert
 import org.junit.Assert.*
@@ -22,53 +24,53 @@ class TtlWrappersTest {
     @ConditionalIgnoreRule.ConditionalIgnore(condition = BelowJava8::class)
     fun test_null() {
         val supplier: Supplier<String>? = null
-        assertNull(TtlWrappers.wrap(supplier))
-        assertNull(TtlWrappers.unwrap(supplier))
+        assertNull(wrap(supplier))
+        assertNull(unwrap(supplier))
 
         val consumer: Consumer<String>? = null
-        assertNull(TtlWrappers.unwrap(consumer))
-        assertNull(TtlWrappers.wrap(consumer))
+        assertNull(unwrap(consumer))
+        assertNull(wrap(consumer))
 
         val biConsumer: BiConsumer<String, String>? = null
-        assertNull(TtlWrappers.wrap(biConsumer))
-        assertNull(TtlWrappers.unwrap(biConsumer))
+        assertNull(wrap(biConsumer))
+        assertNull(unwrap(biConsumer))
 
         val function: Function<String, String>? = null
-        assertNull(TtlWrappers.wrap(function))
-        assertNull(TtlWrappers.unwrap(function))
+        assertNull(wrap(function))
+        assertNull(unwrap(function))
 
         val biFunction: BiFunction<String, String, String>? = null
-        assertNull(TtlWrappers.wrap(biFunction))
-        assertNull(TtlWrappers.unwrap(biFunction))
+        assertNull(wrap(biFunction))
+        assertNull(unwrap(biFunction))
     }
 
     @Test
     @ConditionalIgnoreRule.ConditionalIgnore(condition = BelowJava8::class)
     fun wrap_ReWrap_Unwrap_same() {
         val supplier = Supplier { 42 }
-        val ttlSupplier = TtlWrappers.wrap(supplier)
-        assertSame(ttlSupplier, TtlWrappers.wrap(ttlSupplier))
-        assertSame(supplier, TtlWrappers.unwrap(ttlSupplier))
+        val ttlSupplier = wrap(supplier)
+        assertSame(ttlSupplier, wrap(ttlSupplier))
+        assertSame(supplier, unwrap(ttlSupplier))
 
         val consumer = Consumer<String> {}
-        val ttlConsumer = TtlWrappers.wrap(consumer)
-        assertSame(ttlConsumer, TtlWrappers.wrap(ttlConsumer))
-        assertSame(consumer, TtlWrappers.unwrap(ttlConsumer))
+        val ttlConsumer = wrap(consumer)
+        assertSame(ttlConsumer, wrap(ttlConsumer))
+        assertSame(consumer, unwrap(ttlConsumer))
 
         val biConsumer = BiConsumer<String, String> { _, _ -> }
-        val ttlBiConsumer = TtlWrappers.wrap(biConsumer)
-        assertSame(ttlBiConsumer, TtlWrappers.wrap(ttlBiConsumer))
-        assertSame(biConsumer, TtlWrappers.unwrap(ttlBiConsumer))
+        val ttlBiConsumer = wrap(biConsumer)
+        assertSame(ttlBiConsumer, wrap(ttlBiConsumer))
+        assertSame(biConsumer, unwrap(ttlBiConsumer))
 
         val function = Function<String, String> { "" }
-        val ttlFunction = TtlWrappers.wrap(function)
-        assertSame(ttlFunction, TtlWrappers.wrap(ttlFunction))
-        assertSame(function, TtlWrappers.unwrap(ttlFunction))
+        val ttlFunction = wrap(function)
+        assertSame(ttlFunction, wrap(ttlFunction))
+        assertSame(function, unwrap(ttlFunction))
 
         val biFunction = BiFunction<String, String, String> { _, _ -> "" }
-        val ttlBiFunction = TtlWrappers.wrap(biFunction)
-        assertSame(ttlBiFunction, TtlWrappers.wrap(ttlBiFunction))
-        assertSame(biFunction, TtlWrappers.unwrap(ttlBiFunction))
+        val ttlBiFunction = wrap(biFunction)
+        assertSame(ttlBiFunction, wrap(ttlBiFunction))
+        assertSame(biFunction, unwrap(ttlBiFunction))
     }
 
     @Test
@@ -77,7 +79,7 @@ class TtlWrappersTest {
         val ttl = TransmittableThreadLocal<String>()
 
         fun Supplier<String>.ttlWrapThenAsRunnable(): Runnable {
-            val wrap = TtlWrappers.wrap(this)!!
+            val wrap = wrap(this)!!
             return Runnable { wrap.get() }
         }
 
@@ -108,7 +110,7 @@ class TtlWrappersTest {
     @ConditionalIgnoreRule.ConditionalIgnore(condition = BelowJava8::class)
     fun test_Consumer() {
         fun Consumer<String>.ttlWrapThenAsRunnable(): Runnable {
-            val wrap = TtlWrappers.wrap(this)!!
+            val wrap = wrap(this)!!
             return Runnable { wrap.accept("hello ${System.nanoTime()}") }
         }
 
@@ -139,7 +141,7 @@ class TtlWrappersTest {
     @ConditionalIgnoreRule.ConditionalIgnore(condition = BelowJava8::class)
     fun test_BiConsumer() {
         fun BiConsumer<String, String>.ttlWrapThenAsRunnable(): Runnable {
-            val wrap = TtlWrappers.wrap(this)!!
+            val wrap = wrap(this)!!
             return Runnable { wrap.accept("hello ${System.nanoTime()}", "world ${System.nanoTime()}") }
         }
 
@@ -170,7 +172,7 @@ class TtlWrappersTest {
     @ConditionalIgnoreRule.ConditionalIgnore(condition = BelowJava8::class)
     fun test_Function() {
         fun Function<String, String>.ttlWrapThenAsRunnable(): Runnable {
-            val wrap = TtlWrappers.wrap(this)!!
+            val wrap = wrap(this)!!
             return Runnable { wrap.apply("hello ${System.nanoTime()}") }
         }
 
@@ -203,7 +205,7 @@ class TtlWrappersTest {
     @ConditionalIgnoreRule.ConditionalIgnore(condition = BelowJava8::class)
     fun test_BiFunction() {
         fun BiFunction<String, String, String>.ttlWrapThenAsRunnable(): Runnable {
-            val wrap = TtlWrappers.wrap(this)!!
+            val wrap = wrap(this)!!
             return Runnable { wrap.apply("hello ${System.nanoTime()}", "world") }
         }
 

src/test/java/com/alibaba/ttl/threadpool/TtlExecutorsTest.kt

 package com.alibaba.ttl.threadpool
 
 import com.alibaba.noTtlAgentRun
-import com.alibaba.ttl.TtlWrappers
+import com.alibaba.ttl.TtlUnwrap
 import com.alibaba.ttl.threadpool.TtlExecutors.*
 import org.junit.Assert.*
 import org.junit.Test
@@ -23,21 +23,21 @@ class TtlExecutorsTest {
             assertEquals(noTtlAgentRun(), isTtlWrapper(it))
 
             assertSame(newScheduledThreadPool, unwrap(it))
-            assertSame(newScheduledThreadPool, TtlWrappers.unwrap(it))
+            assertSame(newScheduledThreadPool, TtlUnwrap.unwrap(it))
         }
         getTtlExecutorService(newScheduledThreadPool).let {
             if (noTtlAgentRun()) assertTrue(it is ExecutorServiceTtlWrapper)
             assertEquals(noTtlAgentRun(), isTtlWrapper(it))
 
             assertSame(newScheduledThreadPool, unwrap(it))
-            assertSame(newScheduledThreadPool, TtlWrappers.unwrap(it))
+            assertSame(newScheduledThreadPool, TtlUnwrap.unwrap(it))
         }
         getTtlScheduledExecutorService(newScheduledThreadPool).let {
             if (noTtlAgentRun()) assertTrue(it is ScheduledExecutorServiceTtlWrapper)
             assertEquals(noTtlAgentRun(), isTtlWrapper(it))
 
             assertSame(newScheduledThreadPool, unwrap(it))
-            assertSame(newScheduledThreadPool, TtlWrappers.unwrap(it))
+            assertSame(newScheduledThreadPool, TtlUnwrap.unwrap(it))
         }
 
         val threadFactory = ThreadFactory { Thread(it) }
@@ -46,7 +46,7 @@ class TtlExecutorsTest {
             assertTrue(isDisableInheritableThreadFactory(it))
 
             assertSame(threadFactory, unwrap(it))
-            assertSame(threadFactory, TtlWrappers.unwrap(it))
+            assertSame(threadFactory, TtlUnwrap.unwrap(it))
         }
     }
 

src/test/java/com/alibaba/ttl/threadpool/TtlForkJoinPoolHelperTest.kt

@@ -3,7 +3,7 @@ package com.alibaba.ttl.threadpool
 import com.alibaba.support.junit.conditional.BelowJava7
 import com.alibaba.support.junit.conditional.ConditionalIgnoreRule
 import com.alibaba.support.junit.conditional.ConditionalIgnoreRule.ConditionalIgnore
-import com.alibaba.ttl.TtlWrappers
+import com.alibaba.ttl.TtlUnwrap
 import org.junit.Assert.*
 import org.junit.Rule
 import org.junit.Test
@@ -22,7 +22,7 @@ class TtlForkJoinPoolHelperTest {
             assertTrue(TtlForkJoinPoolHelper.isDisableInheritableForkJoinWorkerThreadFactory(it))
 
             assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory, TtlForkJoinPoolHelper.unwrap(it))
-            assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory, TtlWrappers.unwrap(it))
+            assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory, TtlUnwrap.unwrap(it))
         }
     }