IGNITE-26608 Improved JavaDocs.

Author: petrov-mg

modules/commons/src/main/java/org/apache/ignite/internal/thread/context/concurrent/ContextAwareExecutor.java

@@ -18,6 +18,8 @@
 package org.apache.ignite.internal.thread.context.concurrent;
 
 import java.util.concurrent.Executor;
+import org.apache.ignite.internal.thread.context.Context;
+import org.apache.ignite.internal.thread.context.ContextSnapshot;
 import org.apache.ignite.internal.thread.context.function.ContextAwareRunnable;
 import org.jetbrains.annotations.NotNull;
 
@@ -37,9 +39,9 @@ private ContextAwareExecutor(Executor delegate) {
     }
 
     /**
-     * Creates executor wrapper that automatically captures Context Snapshot for the thread that
-     * invokes task execution. Captured Context will be restored before task execution, potentially in another
-     * thread.
+     * Creates executor wrapper that automatically captures {@link ContextSnapshot} of {@link Context} for the thread
+     * that invokes task execution. Captured {@link ContextSnapshot} will be restored before task execution, potentially
+     * in another thread.
      */
     public static Executor wrap(Executor delegate) {
         return delegate == null ? null : new ContextAwareExecutor(delegate);

modules/commons/src/main/java/org/apache/ignite/internal/thread/context/function/ContextAwareCallable.java

@@ -40,19 +40,19 @@ private ContextAwareCallable(Callable<T> delegate, ContextSnapshot snapshot) {
     }
 
     /**
-     * Creates a wrapper that stores a specified {@link Callable} along with the Snapshot of the Context bound
-     * to the thread when this method is called. Captured Context will be restored before {@link Callable} execution,
-     * potentially in another thread.
+     * Creates a wrapper that stores a specified {@link Callable} along with the {@link ContextSnapshot} of {@link Context}
+     * bound to the thread when this method is called. Captured {@link ContextSnapshot} will be restored before
+     * {@link Callable} execution, potentially in another thread.
      */
     public static <T> Callable<T> wrap(Callable<T> delegate) {
         return wrap(delegate, ContextAwareCallable::new);
     }
 
     /**
-     * Creates a wrapper that stores a specified {@link Callable} along with the Snapshot of the Context bound
-     * to the thread when this method is called. Captured Context will be restored before {@link Callable} execution,
-     * potentially in another thread.
-     * If Context holds no data when this method is called, it does nothing and returns original {@link Callable}.
+     * Creates a wrapper that stores a specified {@link Callable} along with the {@link ContextSnapshot} of {@link Context}
+     * bound to the thread when this method is called. Captured {@link ContextSnapshot} will be restored before
+     * {@link Callable} execution, potentially in another thread.
+     * If {@link Context} holds no data when this method is called, it does nothing and returns original {@link Callable}.
      */
     public static <T> Callable<T> wrapIfContextNotEmpty(Callable<T> delegate) {
         return wrap(delegate, ContextAwareCallable::new, true);

modules/commons/src/main/java/org/apache/ignite/internal/thread/context/function/ContextAwareRunnable.java

@@ -37,19 +37,19 @@ public ContextAwareRunnable(Runnable delegate, ContextSnapshot snapshot) {
     }
 
     /**
-     * Creates a wrapper that stores a specified {@link Runnable} along with the Snapshot of the Context bound
-     * to the thread when this method is called. Captured Context will be restored before {@link Runnable} execution,
-     * potentially in another thread.
+     * Creates a wrapper that stores a specified {@link Runnable} along with the {@link ContextSnapshot} of {@link Context}
+     * bound to the thread when this method is called. Captured {@link ContextSnapshot} will be restored before
+     * {@link Runnable} execution, potentially in another thread.
      */
     public static Runnable wrap(Runnable delegate) {
         return wrap(delegate, ContextAwareRunnable::new);
     }
 
     /**
-     * Creates a wrapper that stores a specified {@link Runnable} along with the Snapshot of the Context bound
-     * to the thread when this method is called. Captured Context will be restored before {@link Runnable} execution,
-     * potentially in another thread.
-     * If Context holds no data when this method is called, it does nothing and returns original {@link Runnable}.
+     * Creates a wrapper that stores a specified {@link Runnable} along with the {@link ContextSnapshot} of {@link Context}
+     * bound to the thread when this method is called. Captured {@link ContextSnapshot} will be restored before
+     * {@link Runnable} execution, potentially in another thread.
+     * If {@link Context} holds no data when this method is called, it does nothing and returns original {@link Runnable}.
      */
     public static Runnable wrapIfContextNotEmpty(Runnable delegate) {
         return wrap(delegate, ContextAwareRunnable::new, true);