java.lang.Object
- com.evolveum.midpoint.model.impl.lens.LensElementContext<ShadowType>
- - com.evolveum.midpoint.model.impl.lens.LensProjectionContext

All Implemented Interfaces:

ModelElementContext<ShadowType>, ModelProjectionContext, DebugDumpable, Serializable, Cloneable
```
public class LensProjectionContext
extends LensElementContext<ShadowType>
implements ModelProjectionContext
```
Author:

semancik

See Also:

Serialized Form

Field Summary
- Fields inherited from class com.evolveum.midpoint.model.impl.lens.LensElementContext
  lensContext, state
- Fields inherited from interface com.evolveum.midpoint.util.DebugDumpable
  INDENT_STRING

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`addAccountSyncDelta(ObjectDelta<ShadowType> delta)`
`void`	`adopt(PrismContext prismContext)`
`void`	`checkConsistence(String contextDesc)`
`void`	`checkConsistence(String contextDesc, boolean fresh, boolean force)`
`void`	`checkEncrypted()`
`void`	`cleanup()`	Cleans up the contexts by removing some of the working state.
`void`	`clearIntermediateResults()`
`LensProjectionContext`	`clone(LensContext<? extends ObjectType> lensContext)`
`String`	`debugDump(int indent)`
`String`	`debugDump(int indent, boolean showTriples)`
`void`	`determineFullShadowFlag(ShadowType loadedShadow)`	Sets the full shadow flag, based on the situation (including the fetch result).
`ResourceAttributeDefinition<?>`	`findAttributeDefinition(QName attrName)`
`void`	`forEachDelta(Consumer<ObjectDelta<ShadowType>> consumer)`
`ArchetypeType`	`getArchetype()`	TODO is this method ever used?
`List<ArchetypeType>`	`getArchetypes()`	TODO is this method ever used?
`@NotNull AssignmentPolicyEnforcementType`	`getAssignmentPolicyEnforcementMode()`
`Collection<ResourceObjectDefinition>`	`getAuxiliaryObjectClassDefinitions()`
`ValueMetadataType`	`getCachedValueMetadata()`
`CompositeObjectDefinition`	`getCompositeObjectDefinition()`
`@Nullable String`	`getConfiguredFocusArchetypeOid()`	Returns configured focus archetype OID corresponding to resource object type of this projection (if there is one).
`ShadowLifecycleStateType`	`getCurrentShadowState()`
`Collection<ResourceObjectTypeDependencyType>`	`getDependencies()`	Dependencies returned are "almost complete": resource OID and kind are non-null.
`String`	`getDescription()`
`protected String`	`getElementDefaultDesc()`
`protected String`	`getElementDesc()`
`Map<String,PrismObject<ShadowType>>`	`getEntitlementMap()`
`<AH extends AssignmentHolderType> DeltaSetTriple<EvaluatedAssignedResourceObjectConstructionImpl<AH>>`	`getEvaluatedAssignedConstructionDeltaSetTriple()`
`<AH extends AssignmentHolderType> PlainResourceObjectConstruction<AH>`	`getEvaluatedPlainConstruction()`
`ObjectDelta<ShadowType>`	`getExecutableDelta()`	Returns delta suitable for execution.
`@NotNull FocusIdentitySourceType`	`getFocusIdentitySource()`	Returns focus identity source information for data created from this projection.
`String`	`getHumanReadableKind()`
`String`	`getHumanReadableName()`
`@NotNull ProjectionContextKey`	`getKey()`
`ShadowKindType`	`getKind()`
`ObjectDeltaObject<ShadowType>`	`getObjectDeltaObject()`	Returns `ObjectDeltaObject` to be used e.g.
`int`	`getOrder()`
`SecurityPolicyType`	`getProjectionSecurityPolicy()`
`ResourceType`	`getResource()`
`String`	`getResourceName()`
`String`	`getResourceOid()`
`@NotNull String`	`getResourceOidRequired()`
`ResourceSchema`	`getResourceSchema()`
`Map<QName,DeltaSetTriple<ItemValueWithOrigin<PrismContainerValue<ShadowAssociationType>,PrismContainerDefinition<ShadowAssociationType>>>>`	`getSqueezedAssociations()`
`Map<QName,DeltaSetTriple<ItemValueWithOrigin<PrismPropertyValue<?>,PrismPropertyDefinition<?>>>>`	`getSqueezedAttributes()`
`Map<QName,DeltaSetTriple<ItemValueWithOrigin<PrismPropertyValue<QName>,PrismPropertyDefinition<QName>>>>`	`getSqueezedAuxiliaryObjectClasses()`
`PrismObject<ShadowType>`	`getStateBeforeSimulatedOperation()`	Returns the (estimated) state before the simulated operation began.
`ResourceObjectDefinition`	`getStructuralDefinitionIfNotBroken()`
`ResourceObjectDefinition`	`getStructuralObjectDefinition()`
`ObjectDelta<ShadowType>`	`getSummarySecondaryDelta()`	Returns all secondary deltas, merged together.
`ObjectDelta<ShadowType>`	`getSyncDelta()`	Returns synchronization delta.
`SynchronizationIntent`	`getSynchronizationIntent()`	Initial intent regarding the account.
`SynchronizationPolicyDecision`	`getSynchronizationPolicyDecision()`	Decision regarding the account.
`SynchronizationSituationType`	`getSynchronizationSituationDetected()`
`SynchronizationSituationType`	`getSynchronizationSituationResolved()`
`String`	`getTag()`
`int`	`getWave()`
`boolean`	`hasDependentContext()`	Returns true if there is any context that depends on us.
`boolean`	`hasFullShadow()`	Returns true if full shadow is available, either loaded or in a create delta.
`boolean`	`hasResource()`
`boolean`	`hasResourceAndIsVisible()`
`boolean`	`isActive()`
`boolean`	`isAdd()`	Be cautious when using this method for `LensProjectionContext`.
`boolean`	`isAdministrativeStatusSupported()`
`Boolean`	`isAssigned()`
`Boolean`	`isAssignedOld()`
`boolean`	`isBroken()`
`boolean`	`isCanProject()`
`boolean`	`isClassified()`
`boolean`	`isCompleted()`
`boolean`	`isCurrentForProjection()`	Returns true if the projection is "current" i.e.
`boolean`	`isDefaultForKind(@NotNull ShadowKindType kind)`	Use with care!
`boolean`	`isDelete()`	See also limitations for `LensElementContext.isAdd()`.
`boolean`	`isDependencyTarget(ResourceObjectTypeDependencyType dependency)`	Returns true if the `target` is a target of `dependency` configuration.
`boolean`	`isDoReconciliation()`
`boolean`	`isExists()`
`boolean`	`isFullShadow()`
`boolean`	`isGone()`
`boolean`	`isGoneOrReaping()`
`boolean`	`isHigherOrder()`
`boolean`	`isIgnored()`
`boolean`	`isInboundSyncDisabled(OperationResult result)`
`boolean`	`isInMaintenance()`
`Boolean`	`isLegal()`
`boolean`	`isLegalize()`
`Boolean`	`isLegalOld()`
`boolean`	`isLowerOrderOf(@NotNull LensProjectionContext other)`	Returns true if this context is a "lower order brother" of the specified one.
`boolean`	`isMarkedReadOnly(OperationResult result)`
`boolean`	`isModify()`	TODO description See also limitations for `LensElementContext.isAdd()`.
`boolean`	`isOutboundSyncDisabled(OperationResult result)`
`boolean`	`isReaping()`
`boolean`	`isShadowExistsInRepo()`
`boolean`	`isSynchronizationSource()`
`boolean`	`isToBeArchived()`
`boolean`	`isVisible()`	Is the resource or object class/type visible for the current task execution mode?
`boolean`	`isWaveIncomplete()`
`void`	`markGone()`
`boolean`	`matches(@NotNull ConstructionTargetKey targetKey)`
`boolean`	`matches(@NotNull ConstructionType construction, @NotNull String resourceOid)`	Note that we do not consider the project as matching if it's not classified.
`boolean`	`matches(ProjectionContextKey otherKey, boolean compareOrder)`	TODO clarify this!!!
`void`	`normalize()`
`void`	`refreshAuxiliaryObjectClassDefinitions()`
`void`	`replaceOldAndCurrentObject(String oid, PrismObject<ShadowType> objectOld, PrismObject<ShadowType> objectCurrent)`	Replaces OID, old, and current object state.
`void`	`rot()`
`void`	`rotWithDeltaDeletion()`	TODO
`void`	`setActive(boolean isActive)`
`void`	`setAssigned(boolean isAssigned)`
`void`	`setAssignedOldIfUnknown(Boolean value)`	We want to set "assigned in old state" only once - in projection wave 0 where real "old" values are known.
`void`	`setBroken()`
`void`	`setCachedValueMetadata(ValueMetadataType cachedValueMetadata)`
`void`	`setCanProject(boolean canProject)`
`void`	`setCompleted(boolean completed)`
`void`	`setCurrentObject(@Nullable PrismObject<ShadowType> object)`	Updates the current object.
`void`	`setCurrentObjectAndOid(@NotNull PrismObject<ShadowType> object)`	Used to update current object and also the OID.
`void`	`setDoReconciliation(boolean doReconciliation)`
`void`	`setDoReconciliationFlagIfVolatile()`	We set reconciliation:=TRUE for volatile accounts.
`<AH extends AssignmentHolderType> void`	`setEvaluatedAssignedConstructionDeltaSetTriple(DeltaSetTriple<EvaluatedAssignedResourceObjectConstructionImpl<AH>> evaluatedAssignedConstructionDeltaSetTriple)`
`void`	`setEvaluatedPlainConstruction(PlainResourceObjectConstruction<?> evaluatedPlainConstruction)`
`void`	`setExists(boolean exists)`
`void`	`setFullShadow(boolean fullShadow)`
`void`	`setInitialObject(@NotNull PrismObject<ShadowType> object)`	Sets the value of an object that should be present on the clockwork start: both objectCurrent and objectOld.
`void`	`setKey(@NotNull ProjectionContextKey key)`
`void`	`setLegal(Boolean isLegal)`
`void`	`setLegalOld(Boolean isLegalOld)`
`void`	`setLegalOldIfUnknown(Boolean value)`	We want to set "legal in old state" only once - in projection wave 0 where real "old" values are known.
`void`	`setLoadedObject(@NotNull PrismObject<ShadowType> object)`	Sets current and possibly also old object.
`void`	`setProjectionSecurityPolicy(SecurityPolicyType projectionSecurityPolicy)`
`void`	`setResource(ResourceType resource)`
`void`	`setShadowExistsInRepo(boolean shadowExistsInRepo)`
`void`	`setSqueezedAssociations(Map<QName,DeltaSetTriple<ItemValueWithOrigin<PrismContainerValue<ShadowAssociationType>,PrismContainerDefinition<ShadowAssociationType>>>> squeezedAssociations)`
`void`	`setSqueezedAttributes(Map<QName,DeltaSetTriple<ItemValueWithOrigin<PrismPropertyValue<?>,PrismPropertyDefinition<?>>>> squeezedAttributes)`
`void`	`setSqueezedAuxiliaryObjectClasses(Map<QName,DeltaSetTriple<ItemValueWithOrigin<PrismPropertyValue<QName>,PrismPropertyDefinition<QName>>>> squeezedAuxiliaryObjectClasses)`
`void`	`setSyncAbsoluteTrigger(boolean syncAbsoluteTrigger)`
`void`	`setSyncDelta(ObjectDelta<ShadowType> syncDelta)`
`void`	`setSynchronizationIntent(SynchronizationIntent synchronizationIntent)`
`void`	`setSynchronizationPolicyDecision(SynchronizationPolicyDecision policyDecision)`
`void`	`setSynchronizationSituationDetected(SynchronizationSituationType synchronizationSituationDetected)`
`void`	`setSynchronizationSituationResolved(SynchronizationSituationType synchronizationSituationResolved)`
`void`	`setSynchronizationSource(boolean synchronizationSource)`
`void`	`setWave(int wave)`
`void`	`setWaveIncomplete(boolean waveIncomplete)`
`void`	`simulateDeltaExecution(@NotNull ObjectDelta<ShadowType> delta)`	Updates the state to reflect that a delta was "executed" in simulation mode.
`String`	`toHumanReadableString()`	Return a human readable name of the projection object suitable for logs.
`String`	`toString()`

Methods inherited from class com.evolveum.midpoint.model.impl.lens.LensElementContext
addObjectPolicyRule, addToExecutedDeltas, addToPendingAssignmentPolicyStateModifications, addToPendingObjectPolicyStateModifications, addToPrimaryDelta, checkConsistence, clearCurrentObject, clearPendingPolicyStateModifications, deleteNonTransientComputationResults, forEachObject, getAllConsideredEventMarks, getCredentialsPolicy, getCurrentDelta, getExecutedDeltas, getItemChangeApplicationModeConfiguration, getIteration, getIterationToken, getLensContext, getMatchingEventMarks, getModelContext, getObjectCurrent, getObjectCurrentOrNew, getObjectCurrentOrOld, getObjectDefinition, getObjectNew, getObjectNewOrCurrentOrOld, getObjectNewOrCurrentRequired, getObjectOld, getObjectPolicyRules, getObjectReadVersion, getObjectTypeClass, getOid, getOperation, getPendingAssignmentPolicyStateModifications, getPendingObjectPolicyStateModifications, getPolicyRuleCounter, getPrimaryDelta, getSecondaryDelta, getSecurityPolicy, getSummaryDelta, getSummaryExecutedDelta, getTemporaryContainerId, initializeElementState, isFresh, isOfType, modifyPrimaryDelta, operationMatches, recompute, rememberElementState, represents, resolveTemporaryContainerIds, restoreElementState, setEstimatedOldValuesInPrimaryDelta, setFresh, setIteration, setIterationToken, setObjectPolicyRules, setOid, setPolicyRuleCounter, setPrimaryDelta, setPrimaryDeltaAfterStart, setSecurityPolicy, setupLastChangeExecutionResult, swallowToPrimaryDelta, swallowToSecondaryDelta, swallowToSecondaryDelta, swallowToSecondaryDeltaUnchecked, wasAddExecuted

Methods inherited from class java.lang.Object
clone, 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.ModelElementContext
addToPrimaryDelta, getCurrentDelta, getExecutedDeltas, getMatchingEventMarks, getModelContext, getObjectAny, getObjectCurrent, getObjectNew, getObjectNewOrCurrentOrOld, getObjectOld, getObjectOldOrCurrent, getObjectPolicyRules, getObjectTypeClass, getOid, getPrimaryDelta, getSecondaryDelta, getSummaryDelta, isOfType, setPrimaryDelta

Methods inherited from interface com.evolveum.midpoint.model.api.context.ModelProjectionContext
isTombstone

- Method Detail
  - isDependencyTarget
```
public boolean isDependencyTarget(ResourceObjectTypeDependencyType dependency)
```
    Returns true if the `target` is a target of `dependency` configuration. (Meaning that the source that contains `dependency` among its configured dependencies depends on `target`, i.e. the `dependency` configuration points to `target`.) Precondition: dependency is fully specified (resource, kind, intent are not null).
  - getSyncDelta
```
public ObjectDelta<ShadowType> getSyncDelta()
```
    Description copied from interface: ModelProjectionContext
    
    Returns synchronization delta. Synchronization delta describes changes that have recently happened. MidPoint reacts to these changes by "pulling them in" (e.g. using them in inbound mappings).
    
    Specified by:
    
    getSyncDelta in interface ModelProjectionContext
  - setSyncDelta
```
public void setSyncDelta(ObjectDelta<ShadowType> syncDelta)
```
    Specified by:
    
    setSyncDelta in interface ModelProjectionContext
  - setLoadedObject
```
public void setLoadedObject(@NotNull
                            @NotNull PrismObject<ShadowType> object)
```
    Description copied from class: LensElementContext
    
    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!
    
    Specified by:
    
    setLoadedObject in class LensElementContext<ShadowType>
  - setInitialObject
```
public void setInitialObject(@NotNull
                             @NotNull PrismObject<ShadowType> object)
```
    Description copied from class: LensElementContext
    
    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.
    
    Overrides:
    
    setInitialObject in class LensElementContext<ShadowType>
  - setCurrentObject
```
public void setCurrentObject(@Nullable
                             @Nullable PrismObject<ShadowType> object)
```
    Description copied from class: LensElementContext
    
    Updates the current object. Should be called only from the context loader.
    
    Overrides:
    
    setCurrentObject in class LensElementContext<ShadowType>
  - setCurrentObjectAndOid
```
public void setCurrentObjectAndOid(@NotNull
                                   @NotNull PrismObject<ShadowType> object)
```
    Description copied from class: LensElementContext
    
    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.
    
    Overrides:
    
    setCurrentObjectAndOid in class LensElementContext<ShadowType>
  - replaceOldAndCurrentObject
```
public void replaceOldAndCurrentObject(String oid,
                                       PrismObject<ShadowType> objectOld,
                                       PrismObject<ShadowType> objectCurrent)
```
    Description copied from class: LensElementContext
    
    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!
    
    Overrides:
    
    replaceOldAndCurrentObject in class LensElementContext<ShadowType>
  - getObjectDeltaObject
```
public ObjectDeltaObject<ShadowType> getObjectDeltaObject()
                                                   throws SchemaException,
                                                          ConfigurationException
```
    Returns ObjectDeltaObject to be used e.g. expression evaluation regarding this projection. We use ElementState.getRelativeObjectDeltaObject(), although the "absolute" version should provide more or less the same results. Projections are not updated iteratively, unlike the focus.
    
    Throws:
    
    SchemaException
    
    ConfigurationException
  - getSummarySecondaryDelta
```
public ObjectDelta<ShadowType> getSummarySecondaryDelta()
```
    Description copied from interface: ModelElementContext
    
    Returns all secondary deltas, merged together. (Can take some time to compute. So use with care.) The returned object is (kind of) immutable. Changing it may do strange things, but most likely the changes will be lost.
    
    Specified by:
    
    getSummarySecondaryDelta in interface ModelElementContext<ShadowType>
  - setSyncAbsoluteTrigger
```
public void setSyncAbsoluteTrigger(boolean syncAbsoluteTrigger)
```
  - getWave
```
public int getWave()
```
  - setWave
```
public void setWave(int wave)
```
  - isWaveIncomplete
```
public boolean isWaveIncomplete()
```
  - setWaveIncomplete
```
public void setWaveIncomplete(boolean waveIncomplete)
```
  - isDoReconciliation
```
public boolean isDoReconciliation()
```
  - setDoReconciliation
```
public void setDoReconciliation(boolean doReconciliation)
```
  - getKey
```
@NotNull
public @NotNull ProjectionContextKey getKey()
```
    Specified by:
    
    getKey in interface ModelProjectionContext
  - markGone
```
public void markGone()
```
  - setKey
```
public void setKey(@NotNull
                   @NotNull ProjectionContextKey key)
```
  - matches
```
public boolean matches(@NotNull
                       @NotNull ConstructionTargetKey targetKey)
```
  - matches
```
public boolean matches(@NotNull
                       @NotNull ConstructionType construction,
                       @NotNull
                       @NotNull String resourceOid)
```
    Note that we do not consider the project as matching if it's not classified. The reason is that constructions are targeted to specific kind/intent. There is a chance that this particular context points to a shadow that (if properly classified) would match this, but let's ignore this.
  - isLowerOrderOf
```
public boolean isLowerOrderOf(@NotNull
                              @NotNull LensProjectionContext other)
```
    Returns true if this context is a "lower order brother" of the specified one.
  - matches
```
public boolean matches(ProjectionContextKey otherKey,
                       boolean compareOrder)
```
    TODO clarify this!!!
  - isGone
```
public boolean isGone()
```
    Specified by:
    
    isGone in interface ModelProjectionContext
  - isGoneOrReaping
```
public boolean isGoneOrReaping()
```
  - isReaping
```
public boolean isReaping()
```
  - addAccountSyncDelta
```
public void addAccountSyncDelta(ObjectDelta<ShadowType> delta)
                         throws SchemaException
```
    Throws:
    
    SchemaException
  - isAdd
```
public boolean isAdd()
```
    Description copied from class: LensElementContext
    
    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 synchronizationPolicyDecision at all. See MID-8608 and its fix. It is very unclear and should be clarified.
    
    Specified by:
    
    isAdd in interface ModelElementContext<ShadowType>
    
    Specified by:
    
    isAdd in class LensElementContext<ShadowType>
  - isModify
```
public boolean isModify()
```
    Description copied from class: LensElementContext
    
    TODO description See also limitations for LensElementContext.isAdd().
    
    Overrides:
    
    isModify in class LensElementContext<ShadowType>
  - isDelete
```
public boolean isDelete()
```
    Description copied from class: LensElementContext
    
    See also limitations for LensElementContext.isAdd().
    
    Specified by:
    
    isDelete in interface ModelElementContext<ShadowType>
    
    Specified by:
    
    isDelete in class LensElementContext<ShadowType>
  - getArchetype
```
public ArchetypeType getArchetype()
```
    Description copied from interface: ModelElementContext
    
    TODO is this method ever used?
    
    Specified by:
    
    getArchetype in interface ModelElementContext<ShadowType>
    
    Returns:
    
    Determined archetype of the object. Currently not supported for projections. Since 4.4 structural archetype is returned
  - getArchetypes
```
public List<ArchetypeType> getArchetypes()
```
    Description copied from interface: ModelElementContext
    
    TODO is this method ever used?
    
    Specified by:
    
    getArchetypes in interface ModelElementContext<ShadowType>
    
    Returns:
    
    All archetypes (structural and auxiliary)
  - getResource
```
public ResourceType getResource()
```
    Specified by:
    
    getResource in interface ModelProjectionContext
  - setResource
```
public void setResource(ResourceType resource)
```
  - getEntitlementMap
```
public Map<String,PrismObject<ShadowType>> getEntitlementMap()
```
  - isAssigned
```
public Boolean isAssigned()
```
  - setAssigned
```
public void setAssigned(boolean isAssigned)
```
  - isAssignedOld
```
public Boolean isAssignedOld()
```
  - setAssignedOldIfUnknown
```
public void setAssignedOldIfUnknown(Boolean value)
```
    We want to set "assigned in old state" only once - in projection wave 0 where real "old" values are known. TODO: what should we do with projections that appear later?
  - isActive
```
public boolean isActive()
```
  - setActive
```
public void setActive(boolean isActive)
```
  - isLegal
```
public Boolean isLegal()
```
    Specified by:
    
    isLegal in interface ModelProjectionContext
  - setLegal
```
public void setLegal(Boolean isLegal)
```
  - isLegalOld
```
public Boolean isLegalOld()
```
  - setLegalOld
```
public void setLegalOld(Boolean isLegalOld)
```
  - setLegalOldIfUnknown
```
public void setLegalOldIfUnknown(Boolean value)
```
    We want to set "legal in old state" only once - in projection wave 0 where real "old" values are known. TODO: what should we do with projections that appear later?
  - isExists
```
public boolean isExists()
```
    Specified by:
    
    isExists in interface ModelProjectionContext
  - setExists
```
public void setExists(boolean exists)
```
  - isShadowExistsInRepo
```
public boolean isShadowExistsInRepo()
```
  - setShadowExistsInRepo
```
public void setShadowExistsInRepo(boolean shadowExistsInRepo)
```
  - getSynchronizationIntent
```
public SynchronizationIntent getSynchronizationIntent()
```
    Description copied from interface: ModelProjectionContext
    
    Initial intent regarding the account. It indicates what the initiator of the operation _wants to do_ with the context. If set to null then the decision is left to "the engine". Null is also a typical value when the context is created. It may be pre-set under some circumstances, e.g. if an account is being unlinked.
    
    Specified by:
    
    getSynchronizationIntent in interface ModelProjectionContext
  - setSynchronizationIntent
```
public void setSynchronizationIntent(SynchronizationIntent synchronizationIntent)
```
  - getSynchronizationPolicyDecision
```
public SynchronizationPolicyDecision getSynchronizationPolicyDecision()
```
    Description copied from interface: ModelProjectionContext
    
    Decision regarding the account. It describes the overall situation of the account e.g. whether account is added, is to be deleted, unliked, etc. If set to null no decision was made yet. Null is also a typical value when the context is created.
    
    Specified by:
    
    getSynchronizationPolicyDecision in interface ModelProjectionContext
    
    See Also:
    
    SynchronizationPolicyDecision
  - setSynchronizationPolicyDecision
```
public void setSynchronizationPolicyDecision(SynchronizationPolicyDecision policyDecision)
```
  - setBroken
```
public void setBroken()
```
  - getSynchronizationSituationDetected
```
public SynchronizationSituationType getSynchronizationSituationDetected()
```
  - setSynchronizationSituationDetected
```
public void setSynchronizationSituationDetected(SynchronizationSituationType synchronizationSituationDetected)
```
  - getSynchronizationSituationResolved
```
public SynchronizationSituationType getSynchronizationSituationResolved()
```
  - setSynchronizationSituationResolved
```
public void setSynchronizationSituationResolved(SynchronizationSituationType synchronizationSituationResolved)
```
  - isFullShadow
```
public boolean isFullShadow()
```
    Specified by:
    
    isFullShadow in interface ModelProjectionContext
  - hasFullShadow
```
public boolean hasFullShadow()
```
    Returns true if full shadow is available, either loaded or in a create delta.
  - setFullShadow
```
public void setFullShadow(boolean fullShadow)
```
  - getKind
```
public ShadowKindType getKind()
```
  - getEvaluatedAssignedConstructionDeltaSetTriple
```
public <AH extends AssignmentHolderType> DeltaSetTriple<EvaluatedAssignedResourceObjectConstructionImpl<AH>> getEvaluatedAssignedConstructionDeltaSetTriple()
```
  - setEvaluatedAssignedConstructionDeltaSetTriple
```
public <AH extends AssignmentHolderType> void setEvaluatedAssignedConstructionDeltaSetTriple(DeltaSetTriple<EvaluatedAssignedResourceObjectConstructionImpl<AH>> evaluatedAssignedConstructionDeltaSetTriple)
```
  - getEvaluatedPlainConstruction
```
public <AH extends AssignmentHolderType> PlainResourceObjectConstruction<AH> getEvaluatedPlainConstruction()
```
  - setEvaluatedPlainConstruction
```
public void setEvaluatedPlainConstruction(PlainResourceObjectConstruction<?> evaluatedPlainConstruction)
```
  - getSqueezedAttributes
```
public Map<QName,DeltaSetTriple<ItemValueWithOrigin<PrismPropertyValue<?>,PrismPropertyDefinition<?>>>> getSqueezedAttributes()
```
  - setSqueezedAttributes
```
public void setSqueezedAttributes(Map<QName,DeltaSetTriple<ItemValueWithOrigin<PrismPropertyValue<?>,PrismPropertyDefinition<?>>>> squeezedAttributes)
```
  - getSqueezedAssociations
```
public Map<QName,DeltaSetTriple<ItemValueWithOrigin<PrismContainerValue<ShadowAssociationType>,PrismContainerDefinition<ShadowAssociationType>>>> getSqueezedAssociations()
```
  - setSqueezedAssociations
```
public void setSqueezedAssociations(Map<QName,DeltaSetTriple<ItemValueWithOrigin<PrismContainerValue<ShadowAssociationType>,PrismContainerDefinition<ShadowAssociationType>>>> squeezedAssociations)
```
  - getSqueezedAuxiliaryObjectClasses
```
public Map<QName,DeltaSetTriple<ItemValueWithOrigin<PrismPropertyValue<QName>,PrismPropertyDefinition<QName>>>> getSqueezedAuxiliaryObjectClasses()
```
  - setSqueezedAuxiliaryObjectClasses
```
public void setSqueezedAuxiliaryObjectClasses(Map<QName,DeltaSetTriple<ItemValueWithOrigin<PrismPropertyValue<QName>,PrismPropertyDefinition<QName>>>> squeezedAuxiliaryObjectClasses)
```
  - getStructuralDefinitionIfNotBroken
```
public ResourceObjectDefinition getStructuralDefinitionIfNotBroken()
                                                            throws SchemaException,
                                                                   ConfigurationException
```
    Throws:
    
    SchemaException
    
    ConfigurationException
  - getResourceSchema
```
public ResourceSchema getResourceSchema()
                                 throws SchemaException,
                                        ConfigurationException
```
    Throws:
    
    SchemaException
    
    ConfigurationException
  - getStructuralObjectDefinition
```
public ResourceObjectDefinition getStructuralObjectDefinition()
                                                       throws SchemaException,
                                                              ConfigurationException
```
    Throws:
    
    SchemaException
    
    ConfigurationException
  - getAuxiliaryObjectClassDefinitions
```
public Collection<ResourceObjectDefinition> getAuxiliaryObjectClassDefinitions()
                                                                        throws SchemaException,
                                                                               ConfigurationException
```
    Throws:
    
    SchemaException
    
    ConfigurationException
  - refreshAuxiliaryObjectClassDefinitions
```
public void refreshAuxiliaryObjectClassDefinitions()
                                            throws SchemaException,
                                                   ConfigurationException
```
    Throws:
    
    SchemaException
    
    ConfigurationException
  - getCompositeObjectDefinition
```
public CompositeObjectDefinition getCompositeObjectDefinition()
                                                       throws SchemaException,
                                                              ConfigurationException
```
    Specified by:
    
    getCompositeObjectDefinition in interface ModelProjectionContext
    
    Throws:
    
    SchemaException
    
    ConfigurationException
  - findAttributeDefinition
```
public ResourceAttributeDefinition<?> findAttributeDefinition(QName attrName)
                                                       throws SchemaException,
                                                              ConfigurationException
```
    Throws:
    
    SchemaException
    
    ConfigurationException
  - getDependencies
```
public Collection<ResourceObjectTypeDependencyType> getDependencies()
                                                             throws SchemaException,
                                                                    ConfigurationException
```
    Description copied from interface: ModelProjectionContext
    
    Dependencies returned are "almost complete": resource OID and kind are non-null. Intent may be null; in that case, the default value has to be used. TODO decide what to return if the dependency configuration cannot be obtained; currently it's an empty list
    
    Specified by:
    
    getDependencies in interface ModelProjectionContext
    
    Throws:
    
    SchemaException
    
    ConfigurationException
  - getProjectionSecurityPolicy
```
public SecurityPolicyType getProjectionSecurityPolicy()
```
  - setProjectionSecurityPolicy
```
public void setProjectionSecurityPolicy(SecurityPolicyType projectionSecurityPolicy)
```
  - setCanProject
```
public void setCanProject(boolean canProject)
```
  - isCanProject
```
public boolean isCanProject()
```
  - getAssignmentPolicyEnforcementMode
```
@NotNull
public @NotNull AssignmentPolicyEnforcementType getAssignmentPolicyEnforcementMode()
                                                                            throws SchemaException,
                                                                                   ConfigurationException
```
    Throws:
    
    SchemaException
    
    ConfigurationException
  - isLegalize
```
public boolean isLegalize()
                   throws SchemaException,
                          ConfigurationException
```
    Throws:
    
    SchemaException
    
    ConfigurationException
  - clearIntermediateResults
```
public void clearIntermediateResults()
```
  - getExecutableDelta
```
public ObjectDelta<ShadowType> getExecutableDelta()
                                           throws SchemaException,
                                                  ConfigurationException
```
    Description copied from interface: ModelProjectionContext
    
    Returns delta suitable for execution. The primary and secondary deltas may not make complete sense all by themselves. E.g. they may both be MODIFY deltas even in case that the account should be created. The deltas begin to make sense only if combined with sync decision. This method provides the deltas all combined and ready for execution.
    
    Specified by:
    
    getExecutableDelta in interface ModelProjectionContext
    
    Throws:
    
    SchemaException
    
    ConfigurationException
  - checkConsistence
```
public void checkConsistence(String contextDesc)
```
    Specified by:
    
    checkConsistence in class LensElementContext<ShadowType>
  - checkConsistence
```
public void checkConsistence(String contextDesc,
                             boolean fresh,
                             boolean force)
```
  - cleanup
```
public void cleanup()
```
    Description copied from class: LensElementContext
    
    Cleans up the contexts by removing some of the working state. TODO describe more precisely, see also LensElementContext.rot(), LensFocusContext.updateDeltasAfterExecution(), and LensContext.updateAfterExecution()
    
    Specified by:
    
    cleanup in class LensElementContext<ShadowType>
  - normalize
```
public void normalize()
```
    Overrides:
    
    normalize in class LensElementContext<ShadowType>
  - adopt
```
public void adopt(PrismContext prismContext)
           throws SchemaException
```
    Overrides:
    
    adopt in class LensElementContext<ShadowType>
    
    Throws:
    
    SchemaException
  - clone
```
public LensProjectionContext clone(LensContext<? extends ObjectType> lensContext)
```
  - checkEncrypted
```
public void checkEncrypted()
```
    Overrides:
    
    checkEncrypted in class LensElementContext<ShadowType>
  - getHumanReadableName
```
public String getHumanReadableName()
```
    Specified by:
    
    getHumanReadableName in class LensElementContext<ShadowType>
  - debugDump
```
public String debugDump(int indent)
```
    Specified by:
    
    debugDump in interface DebugDumpable
  - debugDump
```
public String debugDump(int indent,
                        boolean showTriples)
```
  - getCurrentShadowState
```
public ShadowLifecycleStateType getCurrentShadowState()
```
  - getElementDefaultDesc
```
protected String getElementDefaultDesc()
```
    Specified by:
    
    getElementDefaultDesc in class LensElementContext<ShadowType>
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - toHumanReadableString
```
public String toHumanReadableString()
```
    Return a human readable name of the projection object suitable for logs.
  - getHumanReadableKind
```
public String getHumanReadableKind()
```
  - getElementDesc
```
protected String getElementDesc()
```
    Overrides:
    
    getElementDesc in class LensElementContext<ShadowType>
  - determineFullShadowFlag
```
public void determineFullShadowFlag(ShadowType loadedShadow)
```
    Sets the full shadow flag, based on the situation (including the fetch result).
  - isToBeArchived
```
public boolean isToBeArchived()
```
  - getResourceOid
```
public String getResourceOid()
```
  - getResourceOidRequired
```
@NotNull
public @NotNull String getResourceOidRequired()
```
  - forEachDelta
```
public void forEachDelta(Consumer<ObjectDelta<ShadowType>> consumer)
```
    Overrides:
    
    forEachDelta in class LensElementContext<ShadowType>
  - getResourceName
```
public String getResourceName()
```
  - setSynchronizationSource
```
public void setSynchronizationSource(boolean synchronizationSource)
```
  - isSynchronizationSource
```
public boolean isSynchronizationSource()
```
  - getDescription
```
public String getDescription()
```
  - isCurrentForProjection
```
@Experimental
public boolean isCurrentForProjection()
```
    Returns true if the projection is "current" i.e. it was not completed and its wave is either not yet determined or equal to the current projection wave.
  - isCompleted
```
public boolean isCompleted()
```
  - setCompleted
```
public void setCompleted(boolean completed)
```
  - rot
```
public void rot()
```
    Overrides:
    
    rot in class LensElementContext<ShadowType>
  - getCachedValueMetadata
```
public ValueMetadataType getCachedValueMetadata()
```
  - setCachedValueMetadata
```
public void setCachedValueMetadata(ValueMetadataType cachedValueMetadata)
```
  - isHigherOrder
```
public boolean isHigherOrder()
```
  - isBroken
```
public boolean isBroken()
```
  - isIgnored
```
public boolean isIgnored()
```
  - setDoReconciliationFlagIfVolatile
```
public void setDoReconciliationFlagIfVolatile()
                                       throws SchemaException,
                                              ConfigurationException
```
    We set reconciliation:=TRUE for volatile accounts. This is to ensure that the changes on such resources will be read back to midPoint. (It is a bit of hack but it looks OK.) See also MID-2436 - volatile objects.
    
    Throws:
    
    SchemaException
    
    ConfigurationException
  - rotWithDeltaDeletion
```
public void rotWithDeltaDeletion()
```
    TODO
  - hasDependentContext
```
public boolean hasDependentContext()
                            throws SchemaException,
                                   ConfigurationException
```
    Returns true if there is any context that depends on us. (Note that "dependency source" means the context that depends on the "dependency target". We are the target here.)
    
    Throws:
    
    SchemaException
    
    ConfigurationException
  - isClassified
```
public boolean isClassified()
```
  - getOrder
```
public int getOrder()
```
  - getTag
```
public String getTag()
```
  - isDefaultForKind
```
@Experimental
public boolean isDefaultForKind(@NotNull
                                @NotNull ShadowKindType kind)
```
    Use with care!
  - getConfiguredFocusArchetypeOid
```
@Nullable
public @Nullable String getConfiguredFocusArchetypeOid()
                                                throws SchemaException,
                                                       ConfigurationException
```
    Returns configured focus archetype OID corresponding to resource object type of this projection (if there is one).
    
    Throws:
    
    SchemaException
    
    ConfigurationException
  - getFocusIdentitySource
```
@NotNull
public @NotNull FocusIdentitySourceType getFocusIdentitySource()
```
    Returns focus identity source information for data created from this projection.
  - isInMaintenance
```
public boolean isInMaintenance()
```
  - isVisible
```
public boolean isVisible()
                  throws SchemaException,
                         ConfigurationException
```
    Is the resource or object class/type visible for the current task execution mode?
    
    Throws:
    
    SchemaException
    
    ConfigurationException
  - hasResourceAndIsVisible
```
public boolean hasResourceAndIsVisible()
                                throws SchemaException,
                                       ConfigurationException
```
    Throws:
    
    SchemaException
    
    ConfigurationException
  - hasResource
```
public boolean hasResource()
```
  - isAdministrativeStatusSupported
```
public boolean isAdministrativeStatusSupported()
                                        throws SchemaException,
                                               ConfigurationException
```
    Throws:
    
    SchemaException
    
    ConfigurationException
  - getStateBeforeSimulatedOperation
```
public PrismObject<ShadowType> getStateBeforeSimulatedOperation()
```
    Returns the (estimated) state before the simulated operation began. Ideally, we would like to return "old object", just as we do in LensFocusContext.getStateBeforeSimulatedOperation(). Unfortunately, the "old object" usually contains only the repo shadow, not the state from the resource (called full shadow). The reason is that when the full shadow is is loaded during processing, it is put into "current", not into "old" object. Hence it's best to take "current object" for projections. Unfortunately, this object is changed when the simulated operation is executed. Therefore, we store its copy before we apply the operation. TODO: Maybe we should get rid of all this hackery, and explicitly remember the first full shadow loaded. But it is not trivial to do so: there are many places where full shadow is (tried to be) loaded. And it is not always clear if we get the full shadow or not. So it is doable, but definitely not simple.
    
    Specified by:
    
    getStateBeforeSimulatedOperation in class LensElementContext<ShadowType>
  - simulateDeltaExecution
```
public void simulateDeltaExecution(@NotNull
                                   @NotNull ObjectDelta<ShadowType> delta)
                            throws SchemaException
```
    Description copied from class: LensElementContext
    
    Updates the state to reflect that a delta was "executed" in simulation mode.
    
    Overrides:
    
    simulateDeltaExecution in class LensElementContext<ShadowType>
    
    Throws:
    
    SchemaException
  - isMarkedReadOnly
```
public boolean isMarkedReadOnly(OperationResult result)
```
  - isInboundSyncDisabled
```
public boolean isInboundSyncDisabled(OperationResult result)
```
  - isOutboundSyncDisabled
```
public boolean isOutboundSyncDisabled(OperationResult result)
```

Class LensProjectionContext

Field Summary

Fields inherited from class com.evolveum.midpoint.model.impl.lens.LensElementContext

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

Method Summary

Methods inherited from class com.evolveum.midpoint.model.impl.lens.LensElementContext

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.ModelElementContext

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

Method Detail

isDependencyTarget

getSyncDelta

setSyncDelta

setLoadedObject

setInitialObject

setCurrentObject

setCurrentObjectAndOid

replaceOldAndCurrentObject

getObjectDeltaObject

getSummarySecondaryDelta

setSyncAbsoluteTrigger

getWave

setWave

isWaveIncomplete

setWaveIncomplete

isDoReconciliation

setDoReconciliation

getKey

markGone

setKey

matches

matches

isLowerOrderOf

matches

isGone

isGoneOrReaping

isReaping

addAccountSyncDelta

isAdd

isModify

isDelete

getArchetype

getArchetypes

getResource

setResource

getEntitlementMap

isAssigned

setAssigned

isAssignedOld

setAssignedOldIfUnknown

isActive

setActive

isLegal

setLegal

isLegalOld

setLegalOld

setLegalOldIfUnknown

isExists

setExists

isShadowExistsInRepo

setShadowExistsInRepo

getSynchronizationIntent

setSynchronizationIntent

getSynchronizationPolicyDecision

setSynchronizationPolicyDecision

setBroken

getSynchronizationSituationDetected

setSynchronizationSituationDetected

getSynchronizationSituationResolved

setSynchronizationSituationResolved

isFullShadow

hasFullShadow

setFullShadow

getKind

getEvaluatedAssignedConstructionDeltaSetTriple

setEvaluatedAssignedConstructionDeltaSetTriple

getEvaluatedPlainConstruction

setEvaluatedPlainConstruction

getSqueezedAttributes