java.lang.Object
- com.evolveum.midpoint.model.impl.lens.LensContext<F>

All Implemented Interfaces:

ModelContext<F>, DebugDumpable, Serializable, Cloneable

Direct Known Subclasses:

LensContextPlaceholder
```
public class LensContext<F extends ObjectType>
extends Object
implements ModelContext<F>, Cloneable
```
Author:

semancik

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static class LensContext.ExportType

static class LensContext.GetOrCreateProjectionContextResult

Field Summary
- Fields inherited from interface com.evolveum.midpoint.util.DebugDumpable
  INDENT_STRING

Constructor Summary

Constructors
Constructor	Description
`LensContext(@NotNull TaskExecutionMode taskExecutionMode)`
`LensContext(Class<F> focusClass, @NotNull TaskExecutionMode taskExecutionMode)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`addConflictingProjectionContext(@NotNull LensProjectionContext conflictingContext)`
`void`	`addHookPreviewResults(String hookUri, Collection<? extends Containerable> results)`
`void`	`addProjectionContext(@NotNull LensProjectionContext projectionContext)`
`void`	`checkAbortRequested()`
`void`	`checkConsistence()`
`void`	`checkConsistenceIfNeeded()`
`void`	`cleanup()`	Cleans up the contexts by removing some of the working state.
`void`	`clearConflictingProjectionContexts()`
`LensContext<F>`	`clone()`
`int`	`computeMaxWaves()`
`LensProjectionContext`	`createDetachedProjectionContext(@NotNull ProjectionContextKey key)`
`LensFocusContext<F>`	`createFocusContext()`
`LensProjectionContext`	`createProjectionContext(@NotNull ProjectionContextKey key)`
`String`	`debugDump(int indent)`
`String`	`debugDump(int indent, boolean showTriples)`
`void`	`deleteNonTransientComputationResults()`	Removes results of any previous computations from the context.
`String`	`dump(boolean showTriples)`
`String`	`dumpAssignmentPolicyRules(int indent, boolean alsoMessages)`
`String`	`dumpObjectPolicyRules(int indent, boolean alsoMessages)`
`LensProjectionContext`	`findFirstNotCompletedProjectionContext(@NotNull ConstructionTargetKey targetKey)`	TODO TODO TODO Do not use this method (yet) Returns the projection context this construction should be applied to.
`LensProjectionContext`	`findFirstProjectionContext(@NotNull ConstructionTargetKey targetKey, boolean acceptReaping)`	TODO
`LensProjectionContext`	`findLowerOrderContext(LensProjectionContext refProjCtx)`
`@Nullable LensProjectionContext`	`findProjectionContext(@NotNull ProjectionContextFilter filter)`
`LensProjectionContext`	`findProjectionContextByKeyExact(@NotNull ProjectionContextKey key)`
`LensProjectionContext`	`findProjectionContextByOid(@NotNull String oid)`	BEWARE! Before you call this method, please consider the fact that there may be more projection contexts matching given shadow OID.
`LensProjectionContext`	`findProjectionContextByOidAndKey(@NotNull String oid, @NotNull ProjectionContextKey key)`	TODO describe this and verify it's OK
`@NotNull Collection<LensProjectionContext>`	`findProjectionContexts(@NotNull ProjectionContextFilter filter)`
`@NotNull List<LensProjectionContext>`	`findProjectionContextsByOid(@NotNull String oid)`
`static <T extends ObjectType> LensContext<T>`	`fromLensContextBean(LensContextType bean, Task task, OperationResult parentResult)`
`ProjectionPolicyType`	`getAccountSynchronizationSettings()`
`int`	`getAllChanges()`	Number of all changes.
`@NotNull Collection<EvaluatedAssignmentImpl<?>>`	`getAllEvaluatedAssignments()`
`String`	`getChannel()`
`@NotNull List<LensProjectionContext>`	`getConflictingProjectionContexts()`
`@NotNull Stream<EvaluatedAssignmentImpl<?>>`	`getEvaluatedAssignmentsStream()`
`DeltaSetTriple<EvaluatedAssignmentImpl<?>>`	`getEvaluatedAssignmentTriple()`
`@NotNull Collection<ObjectDeltaOperation<? extends ObjectType>>`	`getExecutedDeltas()`	Returns all executed deltas, user and all accounts.
`int`	`getExecutionWave()`
`String`	`getExplicitFocusTemplateOid()`
`Class<F>`	`getFocusClass()`
`ConstraintsCheckingStrategyType`	`getFocusConstraintsCheckingStrategy()`
`LensFocusContext<F>`	`getFocusContext()`
`@NotNull LensFocusContext<F>`	`getFocusContextRequired()`
`ObjectDeltaObject<F>`	`getFocusOdoAbsolute()`
`ObjectTemplateType`	`getFocusTemplate()`
`SecurityPolicyType`	`getGlobalSecurityPolicy()`
`Collection<ProjectionContextKey>`	`getHistoricResourceObjects()`
`<T> @NotNull List<T>`	`getHookPreviewResults(@NotNull Class<T> clazz)`
`@NotNull Map<String,Collection<? extends Containerable>>`	`getHookPreviewResultsMap()`
`ClockworkInspector`	`getInspector()`
`InternalsConfigurationType`	`getInternalsConfiguration()`
`String`	`getItemProcessingIdentifier()`
`@NotNull ModelBeans`	`getModelBeans()`
`@NotNull Collection<EvaluatedAssignmentImpl<?>>`	`getNonNegativeEvaluatedAssignments()`
`@NotNull List<ObjectReferenceType>`	`getOperationApprovedBy()`
`@NotNull List<String>`	`getOperationApproverComments()`
`String`	`getOperationQualifier()`
`ModelExecuteOptions`	`getOptions()`
`LensFocusContext<F>`	`getOrCreateFocusContext()`
`LensFocusContext<F>`	`getOrCreateFocusContext(Class<F> explicitFocusClass)`
`static <F extends ObjectType> @NotNull LensContext.GetOrCreateProjectionContextResult`	`getOrCreateProjectionContext(LensContext<F> context, ProjectionContextKey contextKey)`	TODO not sure if this method should be here or in `ProjectionsLoadOperation` (that is currently the only client) The reason for being here is the similarity to `getOrCreateProjectionContext(LensContext, ConstructionTargetKey, boolean)` and coupling with `getOrCreateProjectionContext(LensContext, HumanReadableDescribable, Supplier, Supplier)`.
`static <F extends ObjectType> @NotNull LensContext.GetOrCreateProjectionContextResult`	`getOrCreateProjectionContext(LensContext<F> context, ConstructionTargetKey targetKey, boolean acceptReaping)`
`@NotNull PartialProcessingOptionsType`	`getPartialProcessingOptions()`
`@Nullable PolicyRuleEnforcerPreviewOutputType`	`getPolicyRuleEnforcerPreviewOutput()`
`Collection<ObjectDelta<? extends ObjectType>>`	`getPrimaryChanges()`
`ExpressionProfile`	`getPrivilegedExpressionProfile()`	Expression profile to use for "privileged" operations, such as scripting hooks.
`ConstraintsCheckingStrategyType`	`getProjectionConstraintsCheckingStrategy()`
`@NotNull Collection<LensProjectionContext>`	`getProjectionContexts()`
`Iterator<LensProjectionContext>`	`getProjectionContextsIterator()`
`int`	`getProjectionWave()`
`ProvisioningService`	`getProvisioningService()`
`OperationBusinessContextType`	`getRequestBusinessContext()`
`String`	`getRequestIdentifier()`
`ResourceType`	`getResource(String resourceOid)`	Returns a resource with given OID.
`@NotNull List<LensObjectDeltaOperation<?>>`	`getRottenExecutedDeltas()`
`Long`	`getSequenceCounter(String sequenceOid)`
`Map<String,Long>`	`getSequences()`
`MetadataRecordingStrategyType`	`getShadowMetadataRecordingStrategy()`
`ModelState`	`getState()`
`LensContextStatsType`	`getStats()`
`PrismObject<SystemConfigurationType>`	`getSystemConfiguration()`
`SystemConfigurationType`	`getSystemConfigurationBean()`
`@NotNull TaskExecutionMode`	`getTaskExecutionMode()`
`String`	`getTaskTreeOid(Task task, OperationResult result)`
`@NotNull ObjectTreeDeltas<F>`	`getTreeDeltas()`
`@Nullable String`	`getTriggeringResourceOid()`
`@NotNull Collection<ObjectDeltaOperation<? extends ObjectType>>`	`getUnauditedExecutedDeltas()`	Returns all executed deltas, user and all accounts.
`boolean`	`hasAnyPrimaryChange()`
`boolean`	`hasExplosiveProjection()`
`boolean`	`hasFocusContext()`
`boolean`	`hasFocusOfType(Class<? extends ObjectType> type)`
`boolean`	`hasLowerOrderContext(LensProjectionContext refProjCtx)`
`boolean`	`hasProjectionChange()`
`boolean`	`hasStarted()`
`void`	`incrementProjectionWave()`
`void`	`inspectProjectorFinish()`
`void`	`inspectProjectorStart()`
`boolean`	`isDiscoveryChannel()`
`boolean`	`isDoReconciliationForAllProjections()`
`boolean`	`isExecutionAudited()`
`boolean`	`isExperimentalCodeEnabled()`
`boolean`	`isForcedFocusDelete()`
`boolean`	`isFresh()`
`boolean`	`isInPrimary()`
`boolean`	`isPreview()`
`boolean`	`isRequestAudited()`
`boolean`	`isRequestAuthorized()`
`void`	`markMatchingProjectionsBroken(@NotNull ConstructionType construction, @NotNull String resourceOid)`	Resource OID should correspond to the construction.
`void`	`normalize()`
`boolean`	`primaryFocusItemDeltaExists(ItemPath path)`
`void`	`recompute()`
`void`	`recomputeFocus()`
`void`	`refreshAuxiliaryObjectClassDefinitions()`
`void`	`rememberResource(ResourceType resource)`	Puts resource in the cache for later use.
`void`	`removeIgnoredContexts()`
`void`	`reportProgress(ProgressInformation progress)`
`void`	`resetProjectionWave()`
`void`	`rot(String reason)`	Makes the context and all sub-context non-fresh.
`void`	`setAccountSynchronizationSettings(ProjectionPolicyType accountSynchronizationSettings)`
`void`	`setChannel(String channelUri)`
`void`	`setChannel(QName channelQName)`
`void`	`setDoReconciliationForAllProjections(boolean doReconciliationForAllProjections)`
`void`	`setEvaluatedAssignmentTriple(DeltaSetTriple<EvaluatedAssignmentImpl<?>> evaluatedAssignmentTriple)`
`void`	`setExplicitFocusTemplateOid(String explicitFocusTemplateOid)`
`void`	`setFocusContext(LensFocusContext<F> focusContext)`
`void`	`setFresh(boolean isFresh)`
`void`	`setGlobalSecurityPolicy(SecurityPolicyType globalSecurityPolicy)`
`void`	`setInspector(ClockworkInspector inspector)`
`void`	`setItemProcessingIdentifier(String itemProcessingIdentifier)`
`void`	`setLazyAuditRequest(boolean lazyAuditRequest)`
`void`	`setOptions(ModelExecuteOptions options)`
`void`	`setPolicyRuleEnforcerPreviewOutput(PolicyRuleEnforcerPreviewOutputType policyRuleEnforcerPreviewOutput)`
`void`	`setPreview(boolean preview)`
`void`	`setProgressListeners(Collection<ProgressListener> progressListeners)`
`void`	`setSequenceCounter(String sequenceOid, long counter)`
`void`	`setStartedIfNotYet()`
`void`	`setState(ModelState state)`
`void`	`setStats(LensContextStatsType stats)`
`void`	`setSystemConfiguration(PrismObject<SystemConfigurationType> systemConfiguration)`
`void`	`setTriggeringResourceOid(@NotNull ResourceType triggeringResource)`
`LensContextType`	`toBean()`
`LensContextType`	`toBean(LensContext.ExportType exportType)`	'reduced' means - no full object values (focus, shadow).
`String`	`toString()`
`void`	`updateSystemConfiguration(OperationResult result)`

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.evolveum.midpoint.util.DebugDumpable
debugDump, debugDumpLazily, debugDumpLazily

Methods inherited from interface com.evolveum.midpoint.model.api.context.ModelContext
dumpAssignmentPolicyRules, dumpObjectPolicyRules, isSimulation

Constructor Detail

LensContext

public LensContext(@NotNull
                   @NotNull TaskExecutionMode taskExecutionMode)

LensContext

public LensContext(Class<F> focusClass,
                   @NotNull
                   @NotNull TaskExecutionMode taskExecutionMode)

Method Detail

getOrCreateProjectionContext

@NotNull
public static <F extends ObjectType> @NotNull LensContext.GetOrCreateProjectionContextResult getOrCreateProjectionContext(LensContext<F> context,
                                                                                                                          ProjectionContextKey contextKey)

TODO not sure if this method should be here or in ProjectionsLoadOperation (that is currently the only client) The reason for being here is the similarity to getOrCreateProjectionContext(LensContext, ConstructionTargetKey, boolean) and coupling with getOrCreateProjectionContext(LensContext, HumanReadableDescribable, Supplier, Supplier).

getOrCreateProjectionContext

@NotNull
public static <F extends ObjectType> @NotNull LensContext.GetOrCreateProjectionContextResult getOrCreateProjectionContext(LensContext<F> context,
                                                                                                                          ConstructionTargetKey targetKey,
                                                                                                                          boolean acceptReaping)

hasLowerOrderContext

public boolean hasLowerOrderContext(LensProjectionContext refProjCtx)

findLowerOrderContext

public LensProjectionContext findLowerOrderContext(LensProjectionContext refProjCtx)

getProvisioningService

public ProvisioningService getProvisioningService()

setTriggeringResourceOid

public void setTriggeringResourceOid(@NotNull
                                     @NotNull ResourceType triggeringResource)

getTriggeringResourceOid

@Nullable
public @Nullable String getTriggeringResourceOid()

getRequestIdentifier
```
public String getRequestIdentifier()
```
Specified by:

getRequestIdentifier in interface ModelContext<F extends ObjectType>

getItemProcessingIdentifier

public String getItemProcessingIdentifier()

setItemProcessingIdentifier

public void setItemProcessingIdentifier(String itemProcessingIdentifier)

getState
```
public ModelState getState()
```
Specified by:

getState in interface ModelContext<F extends ObjectType>

setState

public void setState(ModelState state)

getFocusContext
```
public LensFocusContext<F> getFocusContext()
```
Specified by:

getFocusContext in interface ModelContext<F extends ObjectType>

hasFocusContext
```
public boolean hasFocusContext()
```

getFocusContextRequired
```
@NotNull
public @NotNull LensFocusContext<F> getFocusContextRequired()
```
Specified by:

getFocusContextRequired in interface ModelContext<F extends ObjectType>

setFocusContext

public void setFocusContext(LensFocusContext<F> focusContext)

createFocusContext

public LensFocusContext<F> createFocusContext()

getOrCreateFocusContext

public LensFocusContext<F> getOrCreateFocusContext()

getOrCreateFocusContext

public LensFocusContext<F> getOrCreateFocusContext(Class<F> explicitFocusClass)

getProjectionContexts
```
@NotNull
public @NotNull Collection<LensProjectionContext> getProjectionContexts()
```
Specified by:

getProjectionContexts in interface ModelContext<F extends ObjectType>

getProjectionContextsIterator

public Iterator<LensProjectionContext> getProjectionContextsIterator()

addProjectionContext

public void addProjectionContext(@NotNull
                                 @NotNull LensProjectionContext projectionContext)

findProjectionContextByOid
```
public LensProjectionContext findProjectionContextByOid(@NotNull
                                                        @NotNull String oid)
```
BEWARE! Before you call this method, please consider the fact that there may be more projection contexts matching given shadow OID.

findProjectionContextsByOid

@NotNull
public @NotNull List<LensProjectionContext> findProjectionContextsByOid(@NotNull
                                                                        @NotNull String oid)

findProjectionContextByOidAndKey

public LensProjectionContext findProjectionContextByOidAndKey(@NotNull
                                                              @NotNull String oid,
                                                              @NotNull
                                                              @NotNull ProjectionContextKey key)

TODO describe this and verify it's OK

findProjectionContextByKeyExact

public LensProjectionContext findProjectionContextByKeyExact(@NotNull
                                                             @NotNull ProjectionContextKey key)

Specified by:: findProjectionContextByKeyExact in interface ModelContext<F extends ObjectType>

findProjectionContexts

@NotNull
public @NotNull Collection<LensProjectionContext> findProjectionContexts(@NotNull
                                                                         @NotNull ProjectionContextFilter filter)

Specified by:: findProjectionContexts in interface ModelContext<F extends ObjectType>

findProjectionContext

@VisibleForTesting
@Nullable
public @Nullable LensProjectionContext findProjectionContext(@NotNull
                                                             @NotNull ProjectionContextFilter filter)

findFirstNotCompletedProjectionContext
```
public LensProjectionContext findFirstNotCompletedProjectionContext(@NotNull
                                                                    @NotNull ConstructionTargetKey targetKey)
```
TODO TODO TODO Do not use this method (yet) Returns the projection context this construction should be applied to. There may be more matching ones. We return the one that is the next one to be evaluated (according to the waves/ordering). TODO What is more reliable - ordering or waves? Waves may not be computed, while order should be specified. We hope...

findFirstProjectionContext

public LensProjectionContext findFirstProjectionContext(@NotNull
                                                        @NotNull ConstructionTargetKey targetKey,
                                                        boolean acceptReaping)

TODO

getExplicitFocusTemplateOid

public String getExplicitFocusTemplateOid()

setExplicitFocusTemplateOid

public void setExplicitFocusTemplateOid(String explicitFocusTemplateOid)

getFocusTemplate
```
public ObjectTemplateType getFocusTemplate()
```
Specified by:

getFocusTemplate in interface ModelContext<F extends ObjectType>

getSystemConfiguration
```
public PrismObject<SystemConfigurationType> getSystemConfiguration()
```
Specified by:

getSystemConfiguration in interface ModelContext<F extends ObjectType>

getSystemConfigurationBean

public SystemConfigurationType getSystemConfigurationBean()

getInternalsConfiguration

public InternalsConfigurationType getInternalsConfiguration()

setSystemConfiguration

public void setSystemConfiguration(PrismObject<SystemConfigurationType> systemConfiguration)

updateSystemConfiguration

public void updateSystemConfiguration(OperationResult result)
                               throws SchemaException

Throws:: SchemaException

getAccountSynchronizationSettings

public ProjectionPolicyType getAccountSynchronizationSettings()

setAccountSynchronizationSettings

public void setAccountSynchronizationSettings(ProjectionPolicyType accountSynchronizationSettings)

getProjectionWave
```
public int getProjectionWave()
```

incrementProjectionWave
```
public void incrementProjectionWave()
```

resetProjectionWave
```
public void resetProjectionWave()
```

getExecutionWave
```
public int getExecutionWave()
```

computeMaxWaves
```
public int computeMaxWaves()
```

isFresh
```
public boolean isFresh()
```

setFresh

public void setFresh(boolean isFresh)

isRequestAuthorized
```
public boolean isRequestAuthorized()
```

rot
```
public void rot(String reason)
```
Makes the context and all sub-context non-fresh.

getChannel
```
public String getChannel()
```
Specified by:

getChannel in interface ModelContext<F extends ObjectType>

setChannel

public void setChannel(String channelUri)

setChannel

public void setChannel(QName channelQName)

isDoReconciliationForAllProjections

public boolean isDoReconciliationForAllProjections()

setDoReconciliationForAllProjections

public void setDoReconciliationForAllProjections(boolean doReconciliationForAllProjections)

getEvaluatedAssignmentTriple
```
public DeltaSetTriple<EvaluatedAssignmentImpl<?>> getEvaluatedAssignmentTriple()
```
Specified by:

getEvaluatedAssignmentTriple in interface ModelContext<F extends ObjectType>

getEvaluatedAssignmentsStream
```
@NotNull
public @NotNull Stream<EvaluatedAssignmentImpl<?>> getEvaluatedAssignmentsStream()
```
Specified by:

getEvaluatedAssignmentsStream in interface ModelContext<F extends ObjectType>

getNonNegativeEvaluatedAssignments
```
@NotNull
public @NotNull Collection<EvaluatedAssignmentImpl<?>> getNonNegativeEvaluatedAssignments()
```
Specified by:

getNonNegativeEvaluatedAssignments in interface ModelContext<F extends ObjectType>

getAllEvaluatedAssignments
```
@NotNull
public @NotNull Collection<EvaluatedAssignmentImpl<?>> getAllEvaluatedAssignments()
```
Specified by:

getAllEvaluatedAssignments in interface ModelContext<F extends ObjectType>

setEvaluatedAssignmentTriple

public void setEvaluatedAssignmentTriple(DeltaSetTriple<EvaluatedAssignmentImpl<?>> evaluatedAssignmentTriple)

getOptions
```
public ModelExecuteOptions getOptions()
```
Specified by:

getOptions in interface ModelContext<F extends ObjectType>

setOptions

public void setOptions(ModelExecuteOptions options)

getPartialProcessingOptions
```
@NotNull
public @NotNull PartialProcessingOptionsType getPartialProcessingOptions()
```
Specified by:

getPartialProcessingOptions in interface ModelContext<F extends ObjectType>

getInspector

public ClockworkInspector getInspector()

setInspector

public void setInspector(ClockworkInspector inspector)

setLazyAuditRequest

public void setLazyAuditRequest(boolean lazyAuditRequest)

isRequestAudited
```
public boolean isRequestAudited()
```

isExecutionAudited
```
public boolean isExecutionAudited()
```

getStats

public LensContextStatsType getStats()

setStats

public void setStats(LensContextStatsType stats)

getRequestBusinessContext

public OperationBusinessContextType getRequestBusinessContext()

getAllChanges
```
public int getAllChanges()
```
Number of all changes. TODO reconsider this.

Specified by:

getAllChanges in interface ModelContext<F extends ObjectType>

hasAnyPrimaryChange
```
public boolean hasAnyPrimaryChange()
```

getPrimaryChanges

public Collection<ObjectDelta<? extends ObjectType>> getPrimaryChanges()

getExecutedDeltas

@NotNull
public @NotNull Collection<ObjectDeltaOperation<? extends ObjectType>> getExecutedDeltas()

Returns all executed deltas, user and all accounts.

getUnauditedExecutedDeltas

@NotNull
public @NotNull Collection<ObjectDeltaOperation<? extends ObjectType>> getUnauditedExecutedDeltas()

Returns all executed deltas, user and all accounts.

getRottenExecutedDeltas

@NotNull
public @NotNull List<LensObjectDeltaOperation<?>> getRottenExecutedDeltas()

recompute

public void recompute()
               throws SchemaException

Throws:: SchemaException

recomputeFocus

public void recomputeFocus()
                    throws SchemaException

Throws:: SchemaException

refreshAuxiliaryObjectClassDefinitions

public void refreshAuxiliaryObjectClassDefinitions()
                                            throws SchemaException,
                                                   ConfigurationException

Throws:: SchemaException; ConfigurationException

checkAbortRequested
```
public void checkAbortRequested()
```

checkConsistenceIfNeeded

public void checkConsistenceIfNeeded()

checkConsistence
```
public void checkConsistence()
```

createProjectionContext

public LensProjectionContext createProjectionContext(@NotNull
                                                     @NotNull ProjectionContextKey key)

createDetachedProjectionContext

public LensProjectionContext createDetachedProjectionContext(@NotNull
                                                             @NotNull ProjectionContextKey key)

getResource
```
public ResourceType getResource(String resourceOid)
```
Returns a resource with given OID. This is supposed to be efficient, taking the resource from the cache. It assumes the resource is in the cache.

See Also:

rememberResource(ResourceType)

rememberResource
```
public void rememberResource(ResourceType resource)
```
Puts resource in the cache for later use. The resource should be fetched from provisioning and have pre-parsed schemas. So the next time just reuse it without the other overhead.

cleanup
```
public void cleanup()
             throws SchemaException
```
Cleans up the contexts by removing some of the working state. The current wave number is retained. Otherwise it ends up in endless loop.

Throws:

SchemaException

normalize
```
public void normalize()
```

clone
```
public LensContext<F> clone()
```
Overrides:

clone in class Object

getFocusClass
```
public Class<F> getFocusClass()
```
Specified by:

getFocusClass in interface ModelContext<F extends ObjectType>

dump

public String dump(boolean showTriples)

debugDump
```
public String debugDump(int indent)
```
Specified by:

debugDump in interface DebugDumpable

debugDump

public String debugDump(int indent,
                        boolean showTriples)

dumpAssignmentPolicyRules

public String dumpAssignmentPolicyRules(int indent,
                                        boolean alsoMessages)

Specified by:: dumpAssignmentPolicyRules in interface ModelContext<F extends ObjectType>

dumpObjectPolicyRules

public String dumpObjectPolicyRules(int indent,
                                    boolean alsoMessages)

Specified by:: dumpObjectPolicyRules in interface ModelContext<F extends ObjectType>

toBean

public LensContextType toBean()
                       throws SchemaException

Throws:: SchemaException

toBean
```
public LensContextType toBean(LensContext.ExportType exportType)
                       throws SchemaException
```
'reduced' means - no full object values (focus, shadow).
This mode is to be used for re-starting operation after primary-stage approval (here all data are re-loaded; maybe except for objectOld, but let's neglect it for the time being).
It is also to be used for the FINAL stage, where we need the context basically for information about executed deltas.

Throws:

SchemaException

fromLensContextBean

public static <T extends ObjectType> LensContext<T> fromLensContextBean(LensContextType bean,
                                                                        Task task,
                                                                        OperationResult parentResult)
                                                                 throws SchemaException,
                                                                        ConfigurationException,
                                                                        ObjectNotFoundException,
                                                                        CommunicationException,
                                                                        ExpressionEvaluationException

Throws:: SchemaException; ConfigurationException; ObjectNotFoundException; CommunicationException; ExpressionEvaluationException

toString
```
public String toString()
```
Overrides:

toString in class Object

setProgressListeners

public void setProgressListeners(Collection<ProgressListener> progressListeners)

reportProgress
```
public void reportProgress(ProgressInformation progress)
```
Specified by:

reportProgress in interface ModelContext<F extends ObjectType>

getHistoricResourceObjects
```
public Collection<ProjectionContextKey> getHistoricResourceObjects()
```
Specified by:

getHistoricResourceObjects in interface ModelContext<F extends ObjectType>

getSequences

public Map<String,Long> getSequences()

getSequenceCounter
```
public Long getSequenceCounter(String sequenceOid)
```
Specified by:

getSequenceCounter in interface ModelContext<F extends ObjectType>

setSequenceCounter

public void setSequenceCounter(String sequenceOid,
                               long counter)

Specified by:: setSequenceCounter in interface ModelContext<F extends ObjectType>

getConflictingProjectionContexts

@NotNull
public @NotNull List<LensProjectionContext> getConflictingProjectionContexts()

addConflictingProjectionContext

public void addConflictingProjectionContext(@NotNull
                                            @NotNull LensProjectionContext conflictingContext)

clearConflictingProjectionContexts

public void clearConflictingProjectionContexts()

hasExplosiveProjection

public boolean hasExplosiveProjection()
                               throws SchemaException,
                                      ConfigurationException

Throws:: SchemaException; ConfigurationException

getHookPreviewResultsMap

@NotNull
public @NotNull Map<String,Collection<? extends Containerable>> getHookPreviewResultsMap()

Specified by:: getHookPreviewResultsMap in interface ModelContext<F extends ObjectType>

addHookPreviewResults

public void addHookPreviewResults(String hookUri,
                                  Collection<? extends Containerable> results)

getHookPreviewResults

@NotNull
public <T> @NotNull List<T> getHookPreviewResults(@NotNull
                                                  @NotNull Class<T> clazz)

Specified by:: getHookPreviewResults in interface ModelContext<F extends ObjectType>

getPolicyRuleEnforcerPreviewOutput
```
@Nullable
public @Nullable PolicyRuleEnforcerPreviewOutputType getPolicyRuleEnforcerPreviewOutput()
```
Specified by:

getPolicyRuleEnforcerPreviewOutput in interface ModelContext<F extends ObjectType>

setPolicyRuleEnforcerPreviewOutput

public void setPolicyRuleEnforcerPreviewOutput(PolicyRuleEnforcerPreviewOutputType policyRuleEnforcerPreviewOutput)

hasProjectionChange

public boolean hasProjectionChange()
                            throws SchemaException,
                                   ConfigurationException

Throws:: SchemaException; ConfigurationException

getGlobalSecurityPolicy

public SecurityPolicyType getGlobalSecurityPolicy()

setGlobalSecurityPolicy

public void setGlobalSecurityPolicy(SecurityPolicyType globalSecurityPolicy)

isPreview
```
public boolean isPreview()
```
Specified by:

isPreview in interface ModelContext<F extends ObjectType>

setPreview

public void setPreview(boolean preview)

getOperationApprovedBy

@NotNull
public @NotNull List<ObjectReferenceType> getOperationApprovedBy()

getOperationApproverComments

@NotNull
public @NotNull List<String> getOperationApproverComments()

getTreeDeltas
```
@NotNull
public @NotNull ObjectTreeDeltas<F> getTreeDeltas()
```
Specified by:

getTreeDeltas in interface ModelContext<F extends ObjectType>

getPrivilegedExpressionProfile
```
public ExpressionProfile getPrivilegedExpressionProfile()
```
Expression profile to use for "privileged" operations, such as scripting hooks.

Specified by:

getPrivilegedExpressionProfile in interface ModelContext<F extends ObjectType>

getFocusConstraintsCheckingStrategy

public ConstraintsCheckingStrategyType getFocusConstraintsCheckingStrategy()

getProjectionConstraintsCheckingStrategy

public ConstraintsCheckingStrategyType getProjectionConstraintsCheckingStrategy()

getOperationQualifier
```
public String getOperationQualifier()
```

removeIgnoredContexts
```
public void removeIgnoredContexts()
```

isInPrimary
```
public boolean isInPrimary()
```

hasFocusOfType

public boolean hasFocusOfType(Class<? extends ObjectType> type)

primaryFocusItemDeltaExists

public boolean primaryFocusItemDeltaExists(ItemPath path)

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.) Used e.g. when restarting operation after being approved.

isExperimentalCodeEnabled

public boolean isExperimentalCodeEnabled()

getTaskTreeOid

public String getTaskTreeOid(Task task,
                             OperationResult result)

Specified by:: getTaskTreeOid in interface ModelContext<F extends ObjectType>

getFocusOdoAbsolute

public ObjectDeltaObject<F> getFocusOdoAbsolute()

isForcedFocusDelete
```
public boolean isForcedFocusDelete()
```

inspectProjectorStart
```
public void inspectProjectorStart()
```

inspectProjectorFinish
```
public void inspectProjectorFinish()
```

hasStarted
```
public boolean hasStarted()
```

setStartedIfNotYet
```
public void setStartedIfNotYet()
```

isDiscoveryChannel
```
public boolean isDiscoveryChannel()
```

markMatchingProjectionsBroken

public void markMatchingProjectionsBroken(@NotNull
                                          @NotNull ConstructionType construction,
                                          @NotNull
                                          @NotNull String resourceOid)

Resource OID should correspond to the construction. (However, it may be missing in the construction bean itself, e.g. if a filter is used there.)

getModelBeans

@NotNull
public @NotNull ModelBeans getModelBeans()

getTaskExecutionMode
```
@NotNull
public @NotNull TaskExecutionMode getTaskExecutionMode()
```
Specified by:

getTaskExecutionMode in interface ModelContext<F extends ObjectType>

getShadowMetadataRecordingStrategy

public MetadataRecordingStrategyType getShadowMetadataRecordingStrategy()

Modifier and Type	Class	Description
`static class`	`LensContext.ExportType`
`static class`	`LensContext.GetOrCreateProjectionContextResult`

Class LensContext<F extends ObjectType>

Nested Class Summary

Field Summary

Fields inherited from interface com.evolveum.midpoint.util.DebugDumpable

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.evolveum.midpoint.util.DebugDumpable

Methods inherited from interface com.evolveum.midpoint.model.api.context.ModelContext

Constructor Detail

LensContext

LensContext

Method Detail

getOrCreateProjectionContext

getOrCreateProjectionContext

hasLowerOrderContext

findLowerOrderContext

getProvisioningService

setTriggeringResourceOid

getTriggeringResourceOid

getRequestIdentifier

getItemProcessingIdentifier

setItemProcessingIdentifier

getState

setState

getFocusContext

hasFocusContext

getFocusContextRequired

setFocusContext

createFocusContext

getOrCreateFocusContext

getOrCreateFocusContext

getProjectionContexts

getProjectionContextsIterator

addProjectionContext

findProjectionContextByOid

findProjectionContextsByOid

findProjectionContextByOidAndKey

findProjectionContextByKeyExact

findProjectionContexts

findProjectionContext

findFirstNotCompletedProjectionContext

findFirstProjectionContext

getExplicitFocusTemplateOid

setExplicitFocusTemplateOid

getFocusTemplate

getSystemConfiguration

getSystemConfigurationBean

getInternalsConfiguration

setSystemConfiguration

updateSystemConfiguration

getAccountSynchronizationSettings

setAccountSynchronizationSettings

getProjectionWave

incrementProjectionWave

resetProjectionWave

getExecutionWave

computeMaxWaves

isFresh

setFresh

isRequestAuthorized

rot

getChannel

setChannel

setChannel

isDoReconciliationForAllProjections

setDoReconciliationForAllProjections

getEvaluatedAssignmentTriple

getEvaluatedAssignmentsStream

getNonNegativeEvaluatedAssignments

getAllEvaluatedAssignments

setEvaluatedAssignmentTriple

getOptions

setOptions

getPartialProcessingOptions

getInspector

setInspector

setLazyAuditRequest

isRequestAudited

isExecutionAudited