Return deltas computed by inbound processing

**What**

Instead of applying the computed delta to the target object directly in
the `AbstractInboundsProcessing` class, move this responsibility to the
caller of inbound processing implementations.

**Why**

Main reason is, that I want to use inbound processing implementation in
the mappings simulation activity. But in there, I need the deltas, not
the target object with them already applied, because I need to write
those deltas to the simulation result. Other option would be to diff the
object with applied deltas with the original object. But that is a waste
of resources.

There is also other reason. The `executeToDeltas` method, originally
computed the deltas, but it also applied them to the target object. But
that is quite counter-intuitive. Considering the method name, I would
expect it will just compute and return the deltas.

By moving the application of the deltas outside, we also gain more
flexibility, because the way how deltas are applied does not need to be
defined by the implementations. That means, the deltas produced by one
implementation, can be used in different ways, depending on the
requirements of the caller.

**Task**: 10992

Author: and-za

model/model-impl/src/main/java/com/evolveum/midpoint/model/impl/lens/projector/focus/InboundProcessor.java

@@ -6,6 +6,7 @@
 
 package com.evolveum.midpoint.model.impl.lens.projector.focus;
 
+import java.util.Collection;
 import javax.xml.datatype.XMLGregorianCalendar;
 
 import org.springframework.beans.factory.annotation.Autowired;
@@ -19,6 +20,7 @@
 import com.evolveum.midpoint.model.impl.lens.projector.loader.ContextLoader;
 import com.evolveum.midpoint.model.impl.lens.projector.util.ProcessorExecution;
 import com.evolveum.midpoint.model.impl.lens.projector.util.ProcessorMethod;
+import com.evolveum.midpoint.prism.delta.ItemDelta;
 import com.evolveum.midpoint.prism.delta.ObjectDelta;
 import com.evolveum.midpoint.schema.result.OperationResult;
 import com.evolveum.midpoint.task.api.Task;
@@ -51,8 +53,8 @@ <F extends FocusType> void processInbounds(
 
         var env = new MappingEvaluationEnvironment(activityDescription, now, task);
 
-        new FullInboundsProcessing<>(context, env)
-                .executeToDeltas(result);
+        final Collection<ItemDelta<?, ?>> deltas = new FullInboundsProcessing<>(context, env).executeToDeltas(result);
+        context.getFocusContextRequired().swallowToSecondaryDelta(deltas);
 
         context.checkConsistenceIfNeeded();
         medic.traceContext(LOGGER, activityDescription, "inbound", false, context, false);

model/model-impl/src/main/java/com/evolveum/midpoint/model/impl/lens/projector/focus/inbounds/AbstractInboundsProcessing.java

@@ -81,12 +81,12 @@ abstract class AbstractInboundsProcessing<T extends Containerable> {
         this.env = env;
     }
 
-    /** Full processing, resulting in deltas being applied (to focus context or target object). */
-    public void executeToDeltas(OperationResult result)
+    /** Full processing, resulting in deltas being computed. */
+    public Collection<ItemDelta<?, ?>> executeToDeltas(OperationResult result)
             throws SchemaException, ObjectNotFoundException, SecurityViolationException,
             CommunicationException, ConfigurationException, ExpressionEvaluationException {
         executeToTriples(result);
-        consolidateTriples(result);
+        return consolidateTriples(result);
     }
 
     /** Partial processing that stops after triples are computed, i.e. just prepares and evaluates the mappings. */
@@ -180,7 +180,7 @@ private <V extends PrismValue, D extends ItemDefinition<?>> void mergeMappingOut
         }
     }
 
-    private void consolidateTriples(OperationResult result)
+    private Collection<ItemDelta<?, ?>> consolidateTriples(OperationResult result)
             throws CommunicationException, ObjectNotFoundException, ConfigurationException, SchemaException,
             SecurityViolationException, ExpressionEvaluationException {
 
@@ -203,7 +203,7 @@ private void consolidateTriples(OperationResult result)
                 result);
         consolidation.computeItemDeltas();
 
-        applyComputedDeltas(consolidation.getItemDeltas());
+        return consolidation.getItemDeltas();
     }
 
     @NotNull private ItemDefinition<?> getItemDefinition(@NotNull ItemPath itemPath) {
@@ -229,8 +229,6 @@ private boolean rangeIsCompletelyDefined(ItemPath itemPath) {
 
     abstract @Nullable LensContext<?> getLensContextIfPresent();
 
-    abstract void applyComputedDeltas(Collection<? extends ItemDelta<?,?>> itemDeltas) throws SchemaException;
-
     public @NotNull DeltaSetTripleIvwoMap getOutputTripleMap() {
         return outputTripleMap;
     }

model/model-impl/src/main/java/com/evolveum/midpoint/model/impl/lens/projector/focus/inbounds/FullInboundsProcessing.java

@@ -217,11 +217,6 @@ Function<ItemPath, Boolean> getFocusPrimaryItemDeltaExistsProvider() {
         }
     }
 
-    @Override
-    void applyComputedDeltas(Collection<? extends ItemDelta<?, ?>> itemDeltas) throws SchemaException {
-        lensContext.getFocusContextRequired().swallowToSecondaryDelta(itemDeltas);
-    }
-
     @Override
     @Nullable LensContext<?> getLensContextIfPresent() {
         return lensContext;

model/model-impl/src/main/java/com/evolveum/midpoint/model/impl/lens/projector/focus/inbounds/SingleShadowInboundsProcessing.java

@@ -55,7 +55,7 @@ public class SingleShadowInboundsProcessing<T extends Containerable> extends Abs
 
     @NotNull private final SingleShadowInboundsProcessingContext<T> ctx;
 
-    private SingleShadowInboundsProcessing(
+    public SingleShadowInboundsProcessing(
             @NotNull SingleShadowInboundsProcessingContext<T> ctx,
             @NotNull MappingEvaluationEnvironment env) {
         super(env);
@@ -70,8 +70,10 @@ public static <C extends Containerable> C evaluate(SingleShadowInboundsProcessin
                 .build();
         try {
 
-            new SingleShadowInboundsProcessing<>(ctx, createEnv(ctx))
+            final Collection<ItemDelta<?, ?>> deltas = new SingleShadowInboundsProcessing<>(ctx, createEnv(ctx))
                     .executeToDeltas(result);
+            LOGGER.trace("Applying deltas to the pre-focus:\n{}", DebugUtil.debugDumpLazily(deltas, 1));
+            ItemDeltaCollectionsUtil.applyTo(deltas, ctx.getPreFocusAsPcv());
 
             var focus = ctx.getPreFocus();
             LOGGER.debug("Focus:\n{}", focus.debugDumpLazily(1));
@@ -189,13 +191,6 @@ private ObjectTemplateType getObjectTemplate(OperationResult result)
         }
     }
 
-    @Override
-    void applyComputedDeltas(Collection<? extends ItemDelta<?, ?>> itemDeltas) throws SchemaException {
-        LOGGER.trace("Applying deltas to the pre-focus:\n{}", DebugUtil.debugDumpLazily(itemDeltas, 1));
-        ItemDeltaCollectionsUtil.applyTo(
-                itemDeltas, ctx.getPreFocusAsPcv());
-    }
-
     @Override
     @NotNull
     Function<ItemPath, Boolean> getFocusPrimaryItemDeltaExistsProvider() {