Package com.evolveum.midpoint.model.impl.lens

Class LensElementContext<O extends ObjectType>

java.lang.Object
com.evolveum.midpoint.model.impl.lens.LensElementContext<O>
All Implemented Interfaces:
ModelElementContext<O>, DebugDumpable, Serializable, Cloneable
Direct Known Subclasses:
LensFocusContext, LensProjectionContext
public abstract class LensElementContext<O extends ObjectType> extends Object implements ModelElementContext<O>, Cloneable
Lens context for a computation element - a focus or a projection.
Author:
semancik
See Also:

  • Field Details

    • lensContext

      @NotNull protected final @NotNull LensContext<? extends ObjectType> lensContext
      Link to the parent context.

  • Constructor Details

    • LensElementContext

      public LensElementContext(@NotNull @NotNull Class<O> objectTypeClass, @NotNull @NotNull LensContext<? extends ObjectType> lensContext)

  • Method Details

    • getLensContext

      @NotNull public @NotNull LensContext<? extends ObjectType> getLensContext()

    • getModelContext

      @NotNull public @NotNull ModelContext<?> getModelContext()
      Specified by:
      getModelContext in interface ModelElementContext<O extends ObjectType>

    • getObjectTypeClass

      @NotNull public @NotNull Class<O> getObjectTypeClass()
      Specified by:
      getObjectTypeClass in interface ModelElementContext<O extends ObjectType>
      Returns:
      Type of object represented by this context. It is declared when context is created, so the actual type of the object can be its subtype. (Although this is quite unusual.)

    • getObjectDefinition

      @NotNull public @NotNull PrismObjectDefinition<O> getObjectDefinition()

    • represents

      public boolean represents(Class<?> type)

    • isOfType

      public boolean isOfType(Class<?> aClass)
      Specified by:
      isOfType in interface ModelElementContext<O extends ObjectType>
      Returns:
      True if the declared or actual object type is a subtype of aClass.

    • getIteration

      public int getIteration()

    • setIteration

      public void setIteration(int iteration)

    • getIterationToken

      public String getIterationToken()

    • setIterationToken

      public void setIterationToken(String iterationToken)

    • getOid

      public String getOid()
      Specified by:
      getOid in interface ModelElementContext<O extends ObjectType>
      Returns:
      OID of the object. If not determined yet, it is obtained from available sources, like object old, current, new, or primary delta.

    • getObjectOld

      public PrismObject<O> getObjectOld()
      Description copied from interface: ModelElementContext
      "Old" state of the object i.e. the one that was present when the clockwork started. It can be present on the beginning or filled-in during projector execution by the context loaded. This value is used as an "old state" for resource object mappings (in constructions or resources), persona mappings, notifications, policy rules, and so on.
      Specified by:
      getObjectOld in interface ModelElementContext<O extends ObjectType>

    • getStateBeforeSimulatedOperation

      public abstract PrismObject<O> getStateBeforeSimulatedOperation()
      The best estimate how the object looked like before the simulated operation. (Tricky for projections.)

    • getObjectCurrent

      public PrismObject<O> getObjectCurrent()
      Description copied from interface: ModelElementContext
      "Current" state of the object i.e. the one that was present when the current clockwork click started. It is typically filled-in by the context loader. For projections, it is usually the same as the "old" state, as they are not updated iteratively but only once per clockwork run. This value used as an "old state" for focus mappings (in object template or assigned ones). INVARIANT: For LensProjectionContext the `shadowLifecycleState` must be present on this object (if the object is not null).
      Specified by:
      getObjectCurrent in interface ModelElementContext<O extends ObjectType>

    • getObjectCurrentRequired

      @NotNull public @NotNull PrismObject<O> getObjectCurrentRequired()

    • getObjectNew

      public PrismObject<O> getObjectNew()
      Description copied from interface: ModelElementContext
      Expected state of the object after application of currentDelta i.e. item deltas computed during current projection: objectCurrent + currentDelta = objectNew.
      Specified by:
      getObjectNew in interface ModelElementContext<O extends ObjectType>

    • getObjectNewRequired

      @NotNull public @NotNull PrismObject<O> getObjectNewRequired()

    • getObjectNewOrCurrentOrOld

      @Nullable public @Nullable PrismObject<O> getObjectNewOrCurrentOrOld()
      Specified by:
      getObjectNewOrCurrentOrOld in interface ModelElementContext<O extends ObjectType>
      Returns:
      The first non-null object of these: new, current, old. (Or null of all of them all null.)

    • getObjectCurrentOrNew

      @Nullable public @Nullable PrismObject<O> getObjectCurrentOrNew()

    • getObjectNewOrCurrentRequired

      @NotNull public @NotNull PrismObject<O> getObjectNewOrCurrentRequired()

    • getObjectCurrentOrOld

      @Nullable public @Nullable PrismObject<O> getObjectCurrentOrOld()

    • getPrimaryDelta

      public ObjectDelta<O> getPrimaryDelta()
      Specified by:
      getPrimaryDelta in interface ModelElementContext<O extends ObjectType>
      Returns:
      Primary delta i.e. one that the caller specified that has to be executed.

    • getSecondaryDelta

      public ObjectDelta<O> getSecondaryDelta()
      Description copied from interface: ModelElementContext
      Returns secondary delta for the current clockwork click. The caller MUST NOT modify returned object in any way.
      Specified by:
      getSecondaryDelta in interface ModelElementContext<O extends ObjectType>

    • getCurrentDelta

      public ObjectDelta<O> getCurrentDelta()
      Description copied from interface: ModelElementContext
      Returns object delta valid for the current clockwork click. It is either primary delta merged with the current secondary delta (if primary delta was not applied yet), or simply current secondary delta. The returned object is (kind of) immutable. Changing it may do strange things, but most likely the changes will be lost.
      Specified by:
      getCurrentDelta in interface ModelElementContext<O extends ObjectType>

    • getSummaryDelta

      public ObjectDelta<O> getSummaryDelta()
      Description copied from interface: ModelElementContext
      Returns object delta comprising both primary delta and (all) secondary deltas, merged together. The returned object is (kind of) immutable. Changing it may do strange things, but most likely the changes will be lost.
      Specified by:
      getSummaryDelta in interface ModelElementContext<O extends ObjectType>

    • getSummaryExecutedDelta

      public ObjectDelta<O> getSummaryExecutedDelta() throws SchemaException
      Throws:
      SchemaException

    • isModifiedInCurrentDelta

      public boolean isModifiedInCurrentDelta(@NotNull @NotNull ItemPath path)
      For limitations please see ObjectDelta.hasRelatedDelta(ItemPath).

    • getObjectReadVersion

      public String getObjectReadVersion()

    • setOid

      public void setOid(String oid)
      Sets OID of the new object but also to the deltas (if applicable).

    • setInitialObject

      public void setInitialObject(@NotNull @NotNull PrismObject<O> object)
      Sets the value of an object that should be present on the clockwork start: both objectCurrent and objectOld. Assumes that clockwork has not started yet.

    • setLoadedObject

      public abstract void setLoadedObject(@NotNull @NotNull PrismObject<O> object)
      Sets current and possibly also old object. This method is used with freshly loaded object. The object is set as current object. If the old object should be initialized, then the object is also set as old object. Should be used only from the context loader!

    • setCurrentObject

      public void setCurrentObject(@Nullable @Nullable PrismObject<O> objectCurrent)
      Updates the current object. Should be called only from the context loader.

    • clearCurrentObject

      public void clearCurrentObject()
      Clears the current state, e.g. when determining that the object does not exist anymore. Should be used only from the context loader.

    • setCurrentObjectAndOid

      public void setCurrentObjectAndOid(@NotNull @NotNull PrismObject<O> object)
      Used to update current object and also the OID. (In cases when the OID might have changed as well.) Should be called only from the context loader.

    • replaceOldAndCurrentObject

      public void replaceOldAndCurrentObject(String oid, PrismObject<O> objectOld, PrismObject<O> objectCurrent)
      Replaces OID, old, and current object state. Deltas (primary, secondary) are kept untouched. Currently used when doing some magic with resolving conflicts while iterating during the projection of projections. Very dangerous! Use at your own risk!

    • setPrimaryDelta

      public void setPrimaryDelta(ObjectDelta<O> primaryDelta)
      Assumes clockwork was not started.
      Specified by:
      setPrimaryDelta in interface ModelElementContext<O extends ObjectType>

    • setPrimaryDeltaAfterStart

      public void setPrimaryDeltaAfterStart(ObjectDelta<O> primaryDelta)
      Sets the primary delta. Does not check for clockwork not being started, so use with care! TODO The check should be perhaps reduced to "context was not yet used" in the future.

    • addToPrimaryDelta

      public void addToPrimaryDelta(ObjectDelta<O> delta) throws SchemaException
      Adds (merges) a delta into primary delta. Use with care! (This method is 100% safe only when the clockwork has not started.)
      Specified by:
      addToPrimaryDelta in interface ModelElementContext<O extends ObjectType>
      Throws:
      SchemaException

    • swallowToPrimaryDelta

      public void swallowToPrimaryDelta(ItemDelta<?,?> itemDelta) throws SchemaException
      Adds an item delta to primary delta. Dangerous. DO NOT USE unless you know what you are doing. Used from tests and from some scripting hooks.
      Throws:
      SchemaException

    • modifyPrimaryDelta

      public void modifyPrimaryDelta(LensElementContext.DeltaModifier<O> modifier) throws SchemaException
      Modifies the primary delta. Treats cases of delta being null or immutable. Dangerous! Primary delta is generally supposed to be immutable. Use with utmost care!
      Throws:
      SchemaException

    • modifySecondaryDelta

      public void modifySecondaryDelta(LensElementContext.DeltaModifier<O> modifier) throws SchemaException
      Modifies the secondary delta. Do not use! It is a hacking tool only.
      Throws:
      SchemaException

    • setEstimatedOldValuesInPrimaryDelta

      public void setEstimatedOldValuesInPrimaryDelta() throws SchemaException
      Throws:
      SchemaException

    • swallowToSecondaryDelta

      public void swallowToSecondaryDelta(Collection<? extends ItemDelta<?,?>> itemDeltas) throws SchemaException
      Throws:
      SchemaException

    • swallowToSecondaryDeltaUnchecked

      public void swallowToSecondaryDeltaUnchecked(ItemDelta<?,?> itemDelta)

    • swallowToSecondaryDelta

      public void swallowToSecondaryDelta(ItemDelta<?,?> itemDelta) throws SchemaException
      Throws:
      SchemaException

    • initializeElementState

      public void initializeElementState(String oid, PrismObject<O> objectOld, PrismObject<O> objectCurrent, ObjectDelta<O> primaryDelta)
      Initializes the state of the element: sets old/current state and primary delta, clears the secondary delta. Use with care!

    • rememberElementState

      public RememberedElementState<O> rememberElementState()

    • restoreElementState

      public void restoreElementState(@NotNull @NotNull RememberedElementState<O> rememberedState)

    • getPendingObjectPolicyStateModifications

      @NotNull public @NotNull List<ItemDelta<?,?>> getPendingObjectPolicyStateModifications()

    • clearPendingPolicyStateModifications

      public void clearPendingPolicyStateModifications()

    • addToPendingObjectPolicyStateModifications

      public void addToPendingObjectPolicyStateModifications(ItemDelta<?,?> modification)

    • setEvaluatedPolicyStatements

      public void setEvaluatedPolicyStatements(@NotNull @NotNull EvaluatedPolicyStatements evaluatedPolicyStatements)

    • getEvaluatedPolicyStatements

      @NotNull public @NotNull EvaluatedPolicyStatements getEvaluatedPolicyStatements()

    • getPendingAssignmentPolicyStateModifications

      @NotNull public @NotNull Map<AssignmentSpec,List<ItemDelta<?,?>>> getPendingAssignmentPolicyStateModifications()

    • addToPendingAssignmentPolicyStateModifications

      public void addToPendingAssignmentPolicyStateModifications(@NotNull @NotNull AssignmentType assignment, @NotNull @NotNull PlusMinusZero mode, @NotNull @NotNull ItemDelta<?,?> modification)

    • getPolicyRuleCounter

      public Integer getPolicyRuleCounter(String policyRuleIdentifier)

    • setPolicyRuleCounter

      public void setPolicyRuleCounter(String policyRuleIdentifier, int value)

    • getObjectPolicyRules

      @NotNull public @NotNull Collection<EvaluatedPolicyRuleImpl> getObjectPolicyRules()
      Description copied from interface: ModelElementContext
      Returns all policy rules that apply to this object - even those that were not triggered. The policy rules are compiled from all the applicable sources (target, meta-roles, etc.)
      Specified by:
      getObjectPolicyRules in interface ModelElementContext<O extends ObjectType>

    • setObjectPolicyRules

      public void setObjectPolicyRules(Collection<EvaluatedPolicyRuleImpl> policyRules)

    • isAdd

      public abstract boolean isAdd()
      Be cautious when using this method for LensProjectionContext. The projection may be called into existence because a construction is assigned - i.e., no primary delta exists in this case. But the policy decision can also be null: until ActivationProcessor.processProjectionsActivation(LensContext, String, XMLGregorianCalendar, Task, OperationResult) is started - e.g. during the whole focus projection! See also MID-8569. Other problems: If there's no focus, then we don't compute the LensProjectionContext.synchronizationPolicyDecision at all. See MID-8608 and its fix. It is very unclear and should be clarified.
      Specified by:
      isAdd in interface ModelElementContext<O extends ObjectType>

    • isDelete

      public abstract boolean isDelete()
      See also limitations for isAdd().
      Specified by:
      isDelete in interface ModelElementContext<O extends ObjectType>

    • isModify

      public boolean isModify()
      TODO description See also limitations for isAdd().

    • getOperation

      @NotNull public @NotNull SimpleOperationName getOperation()
      Returns a characterization of current operation (add, delete, modify).

    • operationMatches

      public boolean operationMatches(ChangeTypeType operation)

    • getExecutedDeltas

      @NotNull public @NotNull List<LensObjectDeltaOperation<O>> getExecutedDeltas()
      Specified by:
      getExecutedDeltas in interface ModelElementContext<O extends ObjectType>
      Returns:
      List of all executed deltas (in fact, ObjectDeltaOperation objects).

    • getExecutedDeltas

      public List<LensObjectDeltaOperation<O>> getExecutedDeltas(int wave)

    • addToExecutedDeltas

      public void addToExecutedDeltas(LensObjectDeltaOperation<O> executedDelta)

    • wasAddExecuted

      public boolean wasAddExecuted()

    • setupLastChangeExecutionResult

      public ChangeExecutionResult<O> setupLastChangeExecutionResult()

    • simulateDeltaExecution

      public void simulateDeltaExecution(@NotNull @NotNull ObjectDelta<O> delta) throws SchemaException
      Updates the state to reflect that a delta was "executed" in simulation mode.
      Throws:
      SchemaException

    • isFresh

      public boolean isFresh()

    • setFresh

      public void setFresh(boolean fresh)

    • rot

      public void rot()

    • deleteNonTransientComputationResults

      public void deleteNonTransientComputationResults()
      Removes results of any previous computations from the context. (Expecting that transient values are not present. So deals only with non-transient ones. Currently this means deletion of secondary deltas.)

    • cleanup

      public abstract void cleanup()
      Cleans up the contexts by removing some of the working state. TODO describe more precisely, see also rot(), LensFocusContext.updateDeltasAfterExecution(), and LensContext.updateAfterExecution()

    • getSecurityPolicy

      public SecurityPolicyType getSecurityPolicy()
      Returns security policy applicable to the object. This means security policy applicable directory to focus or projection. It will NOT return global security policy.

    • setSecurityPolicy

      public void setSecurityPolicy(SecurityPolicyType securityPolicy)

    • getCredentialsPolicy

      public CredentialsPolicyType getCredentialsPolicy()

    • normalize

      public void normalize()

    • adopt

      public void adopt(PrismContext prismContext) throws SchemaException
      Throws:
      SchemaException

    • checkEncrypted

      public void checkEncrypted()

    • forEachObject

      public void forEachObject(Consumer<PrismObject<O>> consumer)

    • forEachDelta

      public void forEachDelta(Consumer<ObjectDelta<O>> consumer)

    • getElementDefaultDesc

      protected abstract String getElementDefaultDesc()

    • getElementDesc

      protected String getElementDesc()

    • getHumanReadableName

      @NotNull public abstract @NotNull String getHumanReadableName()

    • checkConsistence

      public final void checkConsistence()

    • checkConsistence

      public abstract void checkConsistence(String contextDesc)

    • getTemporaryContainerId

      public int getTemporaryContainerId(@NotNull @NotNull ItemPath itemPath)

    • resolveTemporaryContainerIds

      public void resolveTemporaryContainerIds(ObjectDelta<O> objectDelta) throws SchemaException
      Throws:
      SchemaException

    • getMatchingEventMarksOids

      @NotNull public @NotNull Collection<String> getMatchingEventMarksOids()
      Description copied from interface: ModelElementContext
      Returns OIDs of event marks determined for this focus/projection context.
      Specified by:
      getMatchingEventMarksOids in interface ModelElementContext<O extends ObjectType>

    • getAllConsideredEventMarksOids

      @NotNull public @NotNull Collection<String> getAllConsideredEventMarksOids()

    • getItemChangeApplicationModeConfiguration

      @NotNull public @NotNull ItemChangeApplicationModeConfiguration getItemChangeApplicationModeConfiguration() throws SchemaException, ConfigurationException
      Throws:
      SchemaException
      ConfigurationException

    • hasEffectiveMark

      public boolean hasEffectiveMark(@NotNull @NotNull String oid)
      Description copied from interface: ModelElementContext
      Returns true if the object (focus or projection) has given mark. BEWARE! It relies on marks being present in the current state of the object, i.e. does not look at marks that are eventually computed during the current operation. Experimental.
      Specified by:
      hasEffectiveMark in interface ModelElementContext<O extends ObjectType>