simplify sample

Author: bachuv

samples/src/main/java/io/durabletask/samples/ParentInstanceSample.java

@@ -3,21 +3,16 @@
 package io.durabletask.samples;
 
 import com.microsoft.durabletask.*;
-import lombok.experimental.Delegate;
 
 import javax.annotation.Nullable;
 import java.io.IOException;
 import java.time.Duration;
 import java.util.concurrent.TimeoutException;
 
 /**
- * Demonstrates how to wrap {@link TaskOrchestrationContext} and forward
- * {@link TaskOrchestrationContext#getParentInstance()} through the wrapper so that
- * helper methods built on top of the wrapped context can observe the parent
- * orchestration (if any).
- *
- * <p>This mirrors the .NET {@code ReplaySafeLoggerFactorySample} pattern, where the
- * wrapping context explicitly forwards the abstract {@code Parent} property.
+ * Demonstrates {@link TaskOrchestrationContext#getParentInstance()}: the child orchestration
+ * reports its parent when started as a sub-orchestration, and reports {@code null} when started
+ * standalone.
  *
  * <p>Run with: {@code ./gradlew runParentInstanceSample}
  */
@@ -33,28 +28,26 @@ public static void main(String[] args) throws IOException, InterruptedException,
             @Override
             public TaskOrchestration create() {
                 return ctx -> {
-                    LoggingTaskOrchestrationContext wrapped = new LoggingTaskOrchestrationContext(ctx);
-                    wrapped.log("Starting child sub-orchestration...");
-                    String childResult = wrapped.callSubOrchestrator(
+                    log(ctx, "Starting child sub-orchestration...");
+                    String childResult = ctx.callSubOrchestrator(
                             "ChildOrchestrator", null, String.class).await();
-                    wrapped.log("Child returned: " + childResult);
-                    wrapped.complete(childResult);
+                    log(ctx, "Child returned: " + childResult);
+                    ctx.complete(childResult);
                 };
             }
         });
 
-        // Child orchestration: uses the wrapper helper that reports the parent.
+        // Child orchestration: reads getParentInstance() directly on the context.
         workerBuilder.addOrchestration(new TaskOrchestrationFactory() {
             @Override
             public String getName() { return "ChildOrchestrator"; }
 
             @Override
             public TaskOrchestration create() {
                 return ctx -> {
-                    LoggingTaskOrchestrationContext wrapped = new LoggingTaskOrchestrationContext(ctx);
-                    String result = wrapped.describeParent();
-                    wrapped.log(result);
-                    wrapped.complete(result);
+                    String result = describeParent(ctx.getParentInstance());
+                    log(ctx, result);
+                    ctx.complete(result);
                 };
             }
         });
@@ -64,7 +57,7 @@ public TaskOrchestration create() {
 
         DurableTaskClient client = SampleUtils.newClientBuilder().build();
 
-        // Step 1: Start the parent. The child observes its parent through the wrapper.
+        // Step 1: Start the parent. The child observes its parent via getParentInstance().
         System.out.println("=== Step 1: Sub-orchestration (child has parent) ===");
         String parentId = client.scheduleNewOrchestrationInstance("ParentOrchestrator");
         System.out.println("  Scheduled ParentOrchestrator: " + parentId);
@@ -89,42 +82,19 @@ public TaskOrchestration create() {
         worker.stop();
     }
 
-    /**
-     * Wrapper that forwards every {@link TaskOrchestrationContext} member to an inner
-     * context and exposes replay-safe helpers built on top of it.
-     *
-     * <p>Because {@link TaskOrchestrationContext#getParentInstance()} is abstract,
-     * any wrapper must explicitly forward it. Here we let Lombok {@code @Delegate}
-     * generate the forwarding for every method, including {@code getParentInstance()}.
-     * The {@link #describeParent()} and {@link #log(String)} helpers then build on
-     * the wrapped context without breaking replay safety.
-     */
-    static final class LoggingTaskOrchestrationContext implements TaskOrchestrationContext {
-        @Delegate(types = TaskOrchestrationContext.class)
-        private final TaskOrchestrationContext inner;
-
-        LoggingTaskOrchestrationContext(TaskOrchestrationContext inner) {
-            if (inner == null) {
-                throw new IllegalArgumentException("inner must not be null");
-            }
-            this.inner = inner;
-        }
-
-        /** Returns a string describing this orchestration's parent, or that it has none. */
-        String describeParent() {
-            @Nullable ParentOrchestrationInstance parent = inner.getParentInstance();
-            if (parent != null) {
-                return String.format("I was called by '%s' (instance: %s)",
-                        parent.getName(), parent.getInstanceId());
-            }
-            return "No parent — I was started standalone";
+    /** Returns a string describing the given parent instance, or that there is none. */
+    private static String describeParent(@Nullable ParentOrchestrationInstance parent) {
+        if (parent != null) {
+            return String.format("I was called by '%s' (instance: %s)",
+                    parent.getName(), parent.getInstanceId());
         }
+        return "No parent — I was started standalone";
+    }
 
-        /** Replay-safe console log. */
-        void log(String message) {
-            if (!inner.getIsReplaying()) {
-                System.out.println("  [" + inner.getName() + "] " + message);
-            }
+    /** Replay-safe console log. */
+    private static void log(TaskOrchestrationContext ctx, String message) {
+        if (!ctx.getIsReplaying()) {
+            System.out.println("  [" + ctx.getName() + "] " + message);
         }
     }
 }