java.lang.Object
- ai.timefold.solver.core.impl.score.director.AbstractScoreDirector<Solution_,Score_,Factory_>

All Implemented Interfaces:

ScoreDirector<Solution_>, InnerScoreDirector<Solution_,Score_>, AutoCloseable, Cloneable

Direct Known Subclasses:

EasyScoreDirector, IncrementalScoreDirector
```
public abstract class AbstractScoreDirector<Solution_,Score_ extends Score<Score_>,Factory_ extends AbstractScoreDirectorFactory<Solution_,Score_>>
extends Object
implements InnerScoreDirector<Solution_,Score_>, Cloneable
```
Abstract superclass for ScoreDirector.
Implementation note: Extending classes should follow these guidelines:
- before* method: last statement should be a call to the super method
- after* method: first statement should be a call to the super method
See Also:

ScoreDirector

Field Summary

Fields
Modifier and Type	Field	Description
`protected boolean`	`allChangesWillBeUndoneBeforeStepEnds`
`protected long`	`calculationCount`
`protected boolean`	`constraintMatchEnabledPreference`
`protected boolean`	`expectShadowVariablesInCorrectState`
`protected org.slf4j.Logger`	`logger`
`protected boolean`	`lookUpEnabled`
`protected LookUpManager`	`lookUpManager`
`protected Factory_`	`scoreDirectorFactory`
`protected VariableListenerSupport<Solution_>`	`variableListenerSupport`
`protected long`	`workingEntityListRevision`
`protected Integer`	`workingInitScore`
`protected Solution_`	`workingSolution`

Constructor Summary

Constructors
Modifier	Constructor	Description
`protected`	`AbstractScoreDirector(Factory_ scoreDirectorFactory, boolean lookUpEnabled, boolean constraintMatchEnabledPreference, boolean expectShadowVariablesInCorrectState)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`afterEntityAdded(EntityDescriptor<Solution_> entityDescriptor, Object entity)`
`void`	`afterEntityAdded(Object entity)`
`void`	`afterEntityRemoved(EntityDescriptor<Solution_> entityDescriptor, Object entity)`
`void`	`afterEntityRemoved(Object entity)`
`void`	`afterListVariableChanged(ListVariableDescriptor<Solution_> variableDescriptor, Object entity, int fromIndex, int toIndex)`	Notify the score director after a list variable changes.
`void`	`afterListVariableChanged(Object entity, String variableName, int fromIndex, int toIndex)`
`void`	`afterListVariableElementAssigned(ListVariableDescriptor<Solution_> variableDescriptor, Object element)`	Call this for each element that was assigned (added to a list variable of one entity without being removed from a list variable of another entity).
`void`	`afterListVariableElementAssigned(Object entity, String variableName, Object element)`
`void`	`afterListVariableElementUnassigned(ListVariableDescriptor<Solution_> variableDescriptor, Object element)`	Call this for each element that was unassigned (removed from a list variable of one entity without being added to a list variable of another entity).
`void`	`afterListVariableElementUnassigned(Object entity, String variableName, Object element)`
`void`	`afterProblemFactAdded(Object problemFact)`
`void`	`afterProblemFactRemoved(Object problemFact)`
`void`	`afterProblemPropertyChanged(Object problemFactOrEntity)`
`void`	`afterVariableChanged(VariableDescriptor<Solution_> variableDescriptor, Object entity)`
`void`	`afterVariableChanged(Object entity, String variableName)`
`void`	`assertExpectedUndoMoveScore(Move<Solution_> move, Score_ beforeMoveScore)`	Asserts that if the `Score` is calculated for the current `working solution` in the current `ScoreDirector` (with incremental calculation residue), it is equal to the parameter `beforeMoveScore`.
`void`	`assertExpectedWorkingScore(Score_ expectedWorkingScore, Object completedAction)`	Asserts that if the `Score` is calculated for the current `working solution` in the current `ScoreDirector` (with possibly incremental calculation residue), it is equal to the parameter `expectedWorkingScore`.
`void`	`assertNonNullPlanningIds()`	Asserts that none of the planning facts from `ScoreDirector.getWorkingSolution()` have `PlanningId`s with a null value.
`void`	`assertPredictedScoreFromScratch(Score_ workingScore, Object completedAction)`	Asserts that if the `Score` is calculated for the current `working solution` in a fresh `ScoreDirector` (with no incremental calculation residue), it is equal to the parameter `predictedScore`.
`void`	`assertShadowVariablesAreNotStale(Score_ expectedWorkingScore, Object completedAction)`	Asserts that if all `VariableListener`s are forcibly triggered, and therefore all shadow variables are updated if needed, that none of the shadow variables of the `working solution` change, Then also asserts that the `Score` calculated for the `working solution` afterwards is equal to the parameter `expectedWorkingScore`.
`void`	`assertWorkingScoreFromScratch(Score_ workingScore, Object completedAction)`	Asserts that if the `Score` is calculated for the current `working solution` in a fresh `ScoreDirector` (with no incremental calculation residue), it is equal to the parameter `workingScore`.
`void`	`beforeEntityAdded(EntityDescriptor<Solution_> entityDescriptor, Object entity)`
`void`	`beforeEntityAdded(Object entity)`
`void`	`beforeEntityRemoved(EntityDescriptor<Solution_> entityDescriptor, Object entity)`
`void`	`beforeEntityRemoved(Object entity)`
`void`	`beforeListVariableChanged(ListVariableDescriptor<Solution_> variableDescriptor, Object entity, int fromIndex, int toIndex)`	Notify the score director before a list variable changes.
`void`	`beforeListVariableChanged(Object entity, String variableName, int fromIndex, int toIndex)`
`void`	`beforeListVariableElementAssigned(ListVariableDescriptor<Solution_> variableDescriptor, Object element)`	Call this for each element that will be assigned (added to a list variable of one entity without being removed from a list variable of another entity).
`void`	`beforeListVariableElementAssigned(Object entity, String variableName, Object element)`
`void`	`beforeListVariableElementUnassigned(ListVariableDescriptor<Solution_> variableDescriptor, Object element)`	Call this for each element that will be unassigned (removed from a list variable of one entity without being added to a list variable of another entity).
`void`	`beforeListVariableElementUnassigned(Object entity, String variableName, Object element)`
`void`	`beforeProblemFactAdded(Object problemFact)`
`void`	`beforeProblemFactRemoved(Object problemFact)`
`void`	`beforeProblemPropertyChanged(Object problemFactOrEntity)`
`void`	`beforeVariableChanged(VariableDescriptor<Solution_> variableDescriptor, Object entity)`
`void`	`beforeVariableChanged(Object entity, String variableName)`
`protected String`	`buildScoreCorruptionAnalysis(InnerScoreDirector<Solution_,Score_> uncorruptedScoreDirector, boolean predicted)`
`protected String`	`buildShadowVariableAnalysis(boolean predicted)`
`void`	`changeVariableFacade(VariableDescriptor<Solution_> variableDescriptor, Object entity, Object newValue)`
`AbstractScoreDirector<Solution_,Score_,Factory_>`	`clone()`	Clones this `ScoreDirector` and its `working solution`.
`Solution_`	`cloneSolution(Solution_ originalSolution)`	Returns a planning clone of the solution, which is not a shallow clone nor a deep clone nor a partition clone.
`Solution_`	`cloneWorkingSolution()`	Returns a planning clone of the solution, which is not a shallow clone nor a deep clone nor a partition clone.
`void`	`close()`	Needs to be called after use because some implementations need to clean up their resources.
`InnerScoreDirector<Solution_,Score_>`	`createChildThreadScoreDirector(ChildThreadType childThreadType)`
`Score_`	`doAndProcessMove(Move<Solution_> move, boolean assertMoveScoreFromScratch)`
`void`	`doAndProcessMove(Move<Solution_> move, boolean assertMoveScoreFromScratch, Consumer<Score_> moveProcessor)`
`boolean`	`expectShadowVariablesInCorrectState()`	Inverse shadow variables have a fail-fast for cases where the shadow variable doesn't actually point to its correct inverse.
`void`	`forceTriggerVariableListeners()`	Unlike `ScoreDirector.triggerVariableListeners()` which only triggers notifications already in the queue, this triggers every variable listener on every genuine variable.
`long`	`getCalculationCount()`
`ScoreDefinition<Score_>`	`getScoreDefinition()`
`Factory_`	`getScoreDirectorFactory()`
`SolutionDescriptor<Solution_>`	`getSolutionDescriptor()`
`SupplyManager`	`getSupplyManager()`
`long`	`getWorkingEntityListRevision()`
`Solution_`	`getWorkingSolution()`	The `PlanningSolution` that is used to calculate the `Score`.
`void`	`incrementCalculationCount()`
`protected boolean`	`isConstraintConfiguration(Object problemFactOrEntity)`
`boolean`	`isWorkingEntityListDirty(long expectedWorkingEntityListRevision)`
`<E> E`	`lookUpWorkingObject(E externalObject)`	Translates an entity or fact instance (often from another `Thread` or JVM) to this `ScoreDirector`'s internal working instance.
`<E> E`	`lookUpWorkingObjectOrReturnNull(E externalObject)`	As defined by `ScoreDirector.lookUpWorkingObject(Object)`, but doesn't fail fast if no workingObject was ever added for the externalObject.
`void`	`overwriteConstraintMatchEnabledPreference(boolean constraintMatchEnabledPreference)`
`void`	`resetCalculationCount()`
`void`	`setAllChangesWillBeUndoneBeforeStepEnds(boolean allChangesWillBeUndoneBeforeStepEnds)`	Do not waste performance by propagating changes to step (or higher) mechanisms.
`protected void`	`setCalculatedScore(Score_ score)`
`protected void`	`setWorkingEntityListDirty()`
`void`	`setWorkingSolution(Solution_ workingSolution)`	Note: resetting the working solution does NOT substitute the calls to before/after methods of the `ProblemChangeDirector` during `problem changes`, as these calls are propagated to `variable listeners`, which update shadow variables in the `working solution` to keep it consistent.
`String`	`toString()`
`void`	`triggerVariableListeners()`

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

Methods inherited from interface ai.timefold.solver.core.impl.score.director.InnerScoreDirector
calculateScore, getConstraintMatchTotalMap, getIndictmentMap, isConstraintMatchEnabled, requiresFlushing

- Field Detail
  - logger
```
protected final transient org.slf4j.Logger logger
```
  - scoreDirectorFactory
```
protected final Factory_ extends AbstractScoreDirectorFactory<Solution_,Score_> scoreDirectorFactory
```
  - lookUpEnabled
```
protected final boolean lookUpEnabled
```
  - lookUpManager
```
protected final LookUpManager lookUpManager
```
  - expectShadowVariablesInCorrectState
```
protected final boolean expectShadowVariablesInCorrectState
```
  - variableListenerSupport
```
protected final VariableListenerSupport<Solution_> variableListenerSupport
```
  - constraintMatchEnabledPreference
```
protected boolean constraintMatchEnabledPreference
```
  - workingSolution
```
protected Solution_ workingSolution
```
  - workingEntityListRevision
```
protected long workingEntityListRevision
```
  - workingInitScore
```
protected Integer workingInitScore
```
  - allChangesWillBeUndoneBeforeStepEnds
```
protected boolean allChangesWillBeUndoneBeforeStepEnds
```
  - calculationCount
```
protected long calculationCount
```
- Constructor Detail
  - AbstractScoreDirector
```
protected AbstractScoreDirector(Factory_ scoreDirectorFactory,
                                boolean lookUpEnabled,
                                boolean constraintMatchEnabledPreference,
                                boolean expectShadowVariablesInCorrectState)
```
- Method Detail
  - getScoreDirectorFactory
```
public Factory_ getScoreDirectorFactory()
```
    Specified by:
    
    getScoreDirectorFactory in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Returns:
    
    never null
  - getSolutionDescriptor
```
public SolutionDescriptor<Solution_> getSolutionDescriptor()
```
    Specified by:
    
    getSolutionDescriptor in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Returns:
    
    never null
  - getScoreDefinition
```
public ScoreDefinition<Score_> getScoreDefinition()
```
    Specified by:
    
    getScoreDefinition in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Returns:
    
    never null
  - expectShadowVariablesInCorrectState
```
public boolean expectShadowVariablesInCorrectState()
```
    Description copied from interface: InnerScoreDirector
    
    Inverse shadow variables have a fail-fast for cases where the shadow variable doesn't actually point to its correct inverse. This is very useful to pinpoint improperly initialized solutions.
    However, SolutionManager.update(Object) exists precisely for the purpose of initializing solutions. And when this API is used, the fail-fast must not be triggered as it is guaranteed and expected that the inverse relationships will be wrong. In fact, they will be null.
    For this case and this case only, this method is allowed to return false. All other cases must return true, otherwise a very valuable fail-fast is lost.
    
    Specified by:
    
    expectShadowVariablesInCorrectState in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Returns:
    
    false if the fail-fast on shadow variables should not be triggered
  - overwriteConstraintMatchEnabledPreference
```
public void overwriteConstraintMatchEnabledPreference(boolean constraintMatchEnabledPreference)
```
    Specified by:
    
    overwriteConstraintMatchEnabledPreference in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Parameters:
    
    constraintMatchEnabledPreference - false if a ScoreDirector implementation should not do ConstraintMatch tracking even if it supports it.
  - getWorkingSolution
```
public Solution_ getWorkingSolution()
```
    Description copied from interface: ScoreDirector
    
    The PlanningSolution that is used to calculate the Score.
    Because a Score is best calculated incrementally (by deltas), the ScoreDirector needs to be notified when its working solution changes.
    
    Specified by:
    
    getWorkingSolution in interface ScoreDirector<Solution_>
    
    Returns:
    
    never null
  - getWorkingEntityListRevision
```
public long getWorkingEntityListRevision()
```
    Specified by:
    
    getWorkingEntityListRevision in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Returns:
    
    used to check InnerScoreDirector.isWorkingEntityListDirty(long) later on
  - setAllChangesWillBeUndoneBeforeStepEnds
```
public void setAllChangesWillBeUndoneBeforeStepEnds(boolean allChangesWillBeUndoneBeforeStepEnds)
```
    Description copied from interface: InnerScoreDirector
    
    Do not waste performance by propagating changes to step (or higher) mechanisms.
    
    Specified by:
    
    setAllChangesWillBeUndoneBeforeStepEnds in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Parameters:
    
    allChangesWillBeUndoneBeforeStepEnds - true if all changes will be undone
  - getCalculationCount
```
public long getCalculationCount()
```
    Specified by:
    
    getCalculationCount in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Returns:
    
    at least 0L
  - resetCalculationCount
```
public void resetCalculationCount()
```
    Specified by:
    
    resetCalculationCount in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
  - incrementCalculationCount
```
public void incrementCalculationCount()
```
    Specified by:
    
    incrementCalculationCount in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
  - getSupplyManager
```
public SupplyManager getSupplyManager()
```
    Specified by:
    
    getSupplyManager in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Returns:
    
    never null
  - setWorkingSolution
```
public void setWorkingSolution(Solution_ workingSolution)
```
    Note: resetting the working solution does NOT substitute the calls to before/after methods of the ProblemChangeDirector during problem changes, as these calls are propagated to variable listeners, which update shadow variables in the working solution to keep it consistent.
    
    Specified by:
    
    setWorkingSolution in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Parameters:
    
    workingSolution - never null
  - assertNonNullPlanningIds
```
public void assertNonNullPlanningIds()
```
    Description copied from interface: InnerScoreDirector
    
    Asserts that none of the planning facts from ScoreDirector.getWorkingSolution() have PlanningIds with a null value.
    
    Specified by:
    
    assertNonNullPlanningIds in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
  - doAndProcessMove
```
public Score_ doAndProcessMove(Move<Solution_> move,
                               boolean assertMoveScoreFromScratch)
```
    Specified by:
    
    doAndProcessMove in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Parameters:
    
    move - never null
    
    assertMoveScoreFromScratch - true will hurt performance
    
    Returns:
    
    never null
  - doAndProcessMove
```
public void doAndProcessMove(Move<Solution_> move,
                             boolean assertMoveScoreFromScratch,
                             Consumer<Score_> moveProcessor)
```
    Specified by:
    
    doAndProcessMove in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Parameters:
    
    move - never null
    
    assertMoveScoreFromScratch - true will hurt performance
    
    moveProcessor - never null, use this to store the score as well as call the acceptor and forager
  - isWorkingEntityListDirty
```
public boolean isWorkingEntityListDirty(long expectedWorkingEntityListRevision)
```
    Specified by:
    
    isWorkingEntityListDirty in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Parameters:
    
    expectedWorkingEntityListRevision - an
    
    Returns:
    
    true if the entityList might have a different set of instances now
  - setWorkingEntityListDirty
```
protected void setWorkingEntityListDirty()
```
  - cloneWorkingSolution
```
public Solution_ cloneWorkingSolution()
```
    Description copied from interface: InnerScoreDirector
    
    Returns a planning clone of the solution, which is not a shallow clone nor a deep clone nor a partition clone.
    
    Specified by:
    
    cloneWorkingSolution in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Returns:
    
    never null, planning clone
  - cloneSolution
```
public Solution_ cloneSolution(Solution_ originalSolution)
```
    Description copied from interface: InnerScoreDirector
    
    Returns a planning clone of the solution, which is not a shallow clone nor a deep clone nor a partition clone.
    
    Specified by:
    
    cloneSolution in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Parameters:
    
    originalSolution - never null
    
    Returns:
    
    never null, planning clone
  - triggerVariableListeners
```
public void triggerVariableListeners()
```
    Specified by:
    
    triggerVariableListeners in interface ScoreDirector<Solution_>
  - forceTriggerVariableListeners
```
public void forceTriggerVariableListeners()
```
    Description copied from interface: InnerScoreDirector
    
    Unlike ScoreDirector.triggerVariableListeners() which only triggers notifications already in the queue, this triggers every variable listener on every genuine variable. This is useful in SolutionManager.update(Object) to fill in shadow variable values.
    
    Specified by:
    
    forceTriggerVariableListeners in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
  - setCalculatedScore
```
protected void setCalculatedScore(Score_ score)
```
  - clone
```
public AbstractScoreDirector<Solution_,Score_,Factory_> clone()
```
    Description copied from interface: InnerScoreDirector
    
    Clones this ScoreDirector and its working solution. Use ScoreDirector.getWorkingSolution() to retrieve the working solution of that clone.
    This is heavy method, because it usually breaks incremental score calculation. Use it sparingly. Therefore it's best to clone lazily by delaying the clone call as long as possible.
    
    Specified by:
    
    clone in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Overrides:
    
    clone in class Object
    
    Returns:
    
    never null
  - createChildThreadScoreDirector
```
public InnerScoreDirector<Solution_,Score_> createChildThreadScoreDirector(ChildThreadType childThreadType)
```
    Specified by:
    
    createChildThreadScoreDirector in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
  - close
```
public void close()
```
    Description copied from interface: InnerScoreDirector
    
    Needs to be called after use because some implementations need to clean up their resources.
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
  - beforeEntityAdded
```
public final void beforeEntityAdded(Object entity)
```
    Specified by:
    
    beforeEntityAdded in interface ScoreDirector<Solution_>
  - afterEntityAdded
```
public final void afterEntityAdded(Object entity)
```
    Specified by:
    
    afterEntityAdded in interface ScoreDirector<Solution_>
  - beforeVariableChanged
```
public final void beforeVariableChanged(Object entity,
                                        String variableName)
```
    Specified by:
    
    beforeVariableChanged in interface ScoreDirector<Solution_>
  - afterVariableChanged
```
public final void afterVariableChanged(Object entity,
                                       String variableName)
```
    Specified by:
    
    afterVariableChanged in interface ScoreDirector<Solution_>
  - beforeListVariableElementAssigned
```
public void beforeListVariableElementAssigned(Object entity,
                                              String variableName,
                                              Object element)
```
    Specified by:
    
    beforeListVariableElementAssigned in interface ScoreDirector<Solution_>
  - afterListVariableElementAssigned
```
public void afterListVariableElementAssigned(Object entity,
                                             String variableName,
                                             Object element)
```
    Specified by:
    
    afterListVariableElementAssigned in interface ScoreDirector<Solution_>
  - beforeListVariableElementUnassigned
```
public void beforeListVariableElementUnassigned(Object entity,
                                                String variableName,
                                                Object element)
```
    Specified by:
    
    beforeListVariableElementUnassigned in interface ScoreDirector<Solution_>
  - afterListVariableElementUnassigned
```
public void afterListVariableElementUnassigned(Object entity,
                                               String variableName,
                                               Object element)
```
    Specified by:
    
    afterListVariableElementUnassigned in interface ScoreDirector<Solution_>
  - beforeListVariableChanged
```
public void beforeListVariableChanged(Object entity,
                                      String variableName,
                                      int fromIndex,
                                      int toIndex)
```
    Specified by:
    
    beforeListVariableChanged in interface ScoreDirector<Solution_>
  - afterListVariableChanged
```
public void afterListVariableChanged(Object entity,
                                     String variableName,
                                     int fromIndex,
                                     int toIndex)
```
    Specified by:
    
    afterListVariableChanged in interface ScoreDirector<Solution_>
  - beforeEntityRemoved
```
public final void beforeEntityRemoved(Object entity)
```
    Specified by:
    
    beforeEntityRemoved in interface ScoreDirector<Solution_>
  - afterEntityRemoved
```
public final void afterEntityRemoved(Object entity)
```
    Specified by:
    
    afterEntityRemoved in interface ScoreDirector<Solution_>
  - beforeEntityAdded
```
public void beforeEntityAdded(EntityDescriptor<Solution_> entityDescriptor,
                              Object entity)
```
  - afterEntityAdded
```
public void afterEntityAdded(EntityDescriptor<Solution_> entityDescriptor,
                             Object entity)
```
  - beforeVariableChanged
```
public void beforeVariableChanged(VariableDescriptor<Solution_> variableDescriptor,
                                  Object entity)
```
    Specified by:
    
    beforeVariableChanged in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
  - afterVariableChanged
```
public void afterVariableChanged(VariableDescriptor<Solution_> variableDescriptor,
                                 Object entity)
```
    Specified by:
    
    afterVariableChanged in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
  - changeVariableFacade
```
public void changeVariableFacade(VariableDescriptor<Solution_> variableDescriptor,
                                 Object entity,
                                 Object newValue)
```
    Specified by:
    
    changeVariableFacade in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
  - beforeListVariableElementAssigned
```
public void beforeListVariableElementAssigned(ListVariableDescriptor<Solution_> variableDescriptor,
                                              Object element)
```
    Description copied from interface: InnerScoreDirector
    
    Call this for each element that will be assigned (added to a list variable of one entity without being removed from a list variable of another entity).
    
    Specified by:
    
    beforeListVariableElementAssigned in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Parameters:
    
    variableDescriptor - the list variable descriptor
    
    element - the assigned element
  - afterListVariableElementAssigned
```
public void afterListVariableElementAssigned(ListVariableDescriptor<Solution_> variableDescriptor,
                                             Object element)
```
    Description copied from interface: InnerScoreDirector
    
    Call this for each element that was assigned (added to a list variable of one entity without being removed from a list variable of another entity).
    
    Specified by:
    
    afterListVariableElementAssigned in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Parameters:
    
    variableDescriptor - the list variable descriptor
    
    element - the assigned element
  - beforeListVariableElementUnassigned
```
public void beforeListVariableElementUnassigned(ListVariableDescriptor<Solution_> variableDescriptor,
                                                Object element)
```
    Description copied from interface: InnerScoreDirector
    
    Call this for each element that will be unassigned (removed from a list variable of one entity without being added to a list variable of another entity).
    
    Specified by:
    
    beforeListVariableElementUnassigned in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Parameters:
    
    variableDescriptor - the list variable descriptor
    
    element - the unassigned element
  - afterListVariableElementUnassigned
```
public void afterListVariableElementUnassigned(ListVariableDescriptor<Solution_> variableDescriptor,
                                               Object element)
```
    Description copied from interface: InnerScoreDirector
    
    Call this for each element that was unassigned (removed from a list variable of one entity without being added to a list variable of another entity).
    
    Specified by:
    
    afterListVariableElementUnassigned in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Parameters:
    
    variableDescriptor - the list variable descriptor
    
    element - the unassigned element
  - beforeListVariableChanged
```
public void beforeListVariableChanged(ListVariableDescriptor<Solution_> variableDescriptor,
                                      Object entity,
                                      int fromIndex,
                                      int toIndex)
```
    Description copied from interface: InnerScoreDirector
    Notify the score director before a list variable changes.
    The list variable change includes:
    
    Changing position (index) of one or more elements.
    
    Removing one or more elements from the list variable.
    
    Adding one or more elements to the list variable.
    
    Any mix of the above.
    
    For the sake of variable listeners' efficiency, the change notification requires an index range that contains elements affected by the change. The range starts at fromIndex (inclusive) and ends at toIndex (exclusive).
    The range has to comply with the following contract:
    
    fromIndex must be greater than or equal to 0; toIndex must be less than or equal to the list variable size.
    
    toIndex must be greater than or equal to fromIndex.
    
    The range must contain all elements that are going to be changed.
    
    The range is allowed to contain elements that are not going to be changed.
    
    The range may be empty (fromIndex equals toIndex) if none of the existing list variable elements are going to be changed.
    
    InnerScoreDirector.beforeListVariableElementUnassigned(ListVariableDescriptor, Object) must be called for each element that will be unassigned (removed from a list variable of one entity without being added to a list variable of another entity).
    Specified by:
    
    beforeListVariableChanged in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Parameters:
    
    variableDescriptor - descriptor of the list variable being changed
    
    entity - the entity owning the list variable being changed
    
    fromIndex - low endpoint (inclusive) of the changed range
    
    toIndex - high endpoint (exclusive) of the changed range
  - afterListVariableChanged
```
public void afterListVariableChanged(ListVariableDescriptor<Solution_> variableDescriptor,
                                     Object entity,
                                     int fromIndex,
                                     int toIndex)
```
    Description copied from interface: InnerScoreDirector
    Notify the score director after a list variable changes.
    The list variable change includes:
    
    Changing position (index) of one or more elements.
    
    Removing one or more elements from the list variable.
    
    Adding one or more elements to the list variable.
    
    Any mix of the above.
    
    For the sake of variable listeners' efficiency, the change notification requires an index range that contains elements affected by the change. The range starts at fromIndex (inclusive) and ends at toIndex (exclusive).
    The range has to comply with the following contract:
    
    fromIndex must be greater than or equal to 0; toIndex must be less than or equal to the list variable size.
    
    toIndex must be greater than or equal to fromIndex.
    
    The range must contain all elements that have changed.
    
    The range is allowed to contain elements that have not changed.
    
    The range may be empty (fromIndex equals toIndex) if none of the existing list variable elements have changed.
    
    InnerScoreDirector.afterListVariableElementUnassigned(ListVariableDescriptor, Object) must be called for each element that was unassigned (removed from a list variable of one entity without being added to a list variable of another entity).
    Specified by:
    
    afterListVariableChanged in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Parameters:
    
    variableDescriptor - descriptor of the list variable being changed
    
    entity - the entity owning the list variable being changed
    
    fromIndex - low endpoint (inclusive) of the changed range
    
    toIndex - high endpoint (exclusive) of the changed range
  - beforeEntityRemoved
```
public void beforeEntityRemoved(EntityDescriptor<Solution_> entityDescriptor,
                                Object entity)
```
  - afterEntityRemoved
```
public void afterEntityRemoved(EntityDescriptor<Solution_> entityDescriptor,
                               Object entity)
```
  - beforeProblemFactAdded
```
public void beforeProblemFactAdded(Object problemFact)
```
    Specified by:
    
    beforeProblemFactAdded in interface ScoreDirector<Solution_>
  - afterProblemFactAdded
```
public void afterProblemFactAdded(Object problemFact)
```
    Specified by:
    
    afterProblemFactAdded in interface ScoreDirector<Solution_>
  - beforeProblemPropertyChanged
```
public void beforeProblemPropertyChanged(Object problemFactOrEntity)
```
    Specified by:
    
    beforeProblemPropertyChanged in interface ScoreDirector<Solution_>
  - afterProblemPropertyChanged
```
public void afterProblemPropertyChanged(Object problemFactOrEntity)
```
    Specified by:
    
    afterProblemPropertyChanged in interface ScoreDirector<Solution_>
  - beforeProblemFactRemoved
```
public void beforeProblemFactRemoved(Object problemFact)
```
    Specified by:
    
    beforeProblemFactRemoved in interface ScoreDirector<Solution_>
  - afterProblemFactRemoved
```
public void afterProblemFactRemoved(Object problemFact)
```
    Specified by:
    
    afterProblemFactRemoved in interface ScoreDirector<Solution_>
  - lookUpWorkingObject
```
public <E> E lookUpWorkingObject(E externalObject)
```
    Description copied from interface: ScoreDirector
    
    Translates an entity or fact instance (often from another Thread or JVM) to this ScoreDirector's internal working instance. Useful for move rebasing and in a ProblemChange.
    Matching is determined by the LookUpStrategyType on PlanningSolution. Matching uses a PlanningId by default.
    
    Specified by:
    
    lookUpWorkingObject in interface ScoreDirector<Solution_>
    
    Type Parameters:
    
    E - the object type
    
    Parameters:
    
    externalObject - sometimes null
    
    Returns:
    
    null if externalObject is null
  - lookUpWorkingObjectOrReturnNull
```
public <E> E lookUpWorkingObjectOrReturnNull(E externalObject)
```
    Description copied from interface: ScoreDirector
    
    As defined by ScoreDirector.lookUpWorkingObject(Object), but doesn't fail fast if no workingObject was ever added for the externalObject. It's recommended to use ScoreDirector.lookUpWorkingObject(Object) instead, especially in move rebasing code.
    
    Specified by:
    
    lookUpWorkingObjectOrReturnNull in interface ScoreDirector<Solution_>
    
    Type Parameters:
    
    E - the object type
    
    Parameters:
    
    externalObject - sometimes null
    
    Returns:
    
    null if externalObject is null or if there is no workingObject for externalObject
  - assertExpectedWorkingScore
```
public void assertExpectedWorkingScore(Score_ expectedWorkingScore,
                                       Object completedAction)
```
    Description copied from interface: InnerScoreDirector
    
    Asserts that if the Score is calculated for the current working solution in the current ScoreDirector (with possibly incremental calculation residue), it is equal to the parameter expectedWorkingScore.
    Used to assert that skipping InnerScoreDirector.calculateScore() (when the score is otherwise determined) is correct.
    
    Specified by:
    
    assertExpectedWorkingScore in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Parameters:
    
    expectedWorkingScore - never null
    
    completedAction - sometimes null, when assertion fails then the completedAction's Object.toString() is included in the exception message
  - assertShadowVariablesAreNotStale
```
public void assertShadowVariablesAreNotStale(Score_ expectedWorkingScore,
                                             Object completedAction)
```
    Description copied from interface: InnerScoreDirector
    
    Asserts that if all VariableListeners are forcibly triggered, and therefore all shadow variables are updated if needed, that none of the shadow variables of the working solution change, Then also asserts that the Score calculated for the working solution afterwards is equal to the parameter expectedWorkingScore.
    Used to assert that the shadow variables' state is consistent with the genuine variables' state.
    
    Specified by:
    
    assertShadowVariablesAreNotStale in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Parameters:
    
    expectedWorkingScore - never null
    
    completedAction - sometimes null, when assertion fails then the completedAction's Object.toString() is included in the exception message
  - buildShadowVariableAnalysis
```
protected String buildShadowVariableAnalysis(boolean predicted)
```
    Parameters:
    
    predicted - true if the score was predicted and might have been calculated on another thread
    
    Returns:
    
    never null
  - assertWorkingScoreFromScratch
```
public void assertWorkingScoreFromScratch(Score_ workingScore,
                                          Object completedAction)
```
    Description copied from interface: InnerScoreDirector
    
    Asserts that if the Score is calculated for the current working solution in a fresh ScoreDirector (with no incremental calculation residue), it is equal to the parameter workingScore.
    Furthermore, if the assert fails, a score corruption analysis might be included in the exception message.
    
    Specified by:
    
    assertWorkingScoreFromScratch in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Parameters:
    
    workingScore - never null
    
    completedAction - sometimes null, when assertion fails then the completedAction's Object.toString() is included in the exception message
    
    See Also:
    
    InnerScoreDirectorFactory.assertScoreFromScratch(Solution_)
  - assertPredictedScoreFromScratch
```
public void assertPredictedScoreFromScratch(Score_ workingScore,
                                            Object completedAction)
```
    Description copied from interface: InnerScoreDirector
    
    Asserts that if the Score is calculated for the current working solution in a fresh ScoreDirector (with no incremental calculation residue), it is equal to the parameter predictedScore.
    Furthermore, if the assert fails, a score corruption analysis might be included in the exception message.
    
    Specified by:
    
    assertPredictedScoreFromScratch in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Parameters:
    
    workingScore - never null
    
    completedAction - sometimes null, when assertion fails then the completedAction's Object.toString() is included in the exception message
    
    See Also:
    
    InnerScoreDirectorFactory.assertScoreFromScratch(Solution_)
  - assertExpectedUndoMoveScore
```
public void assertExpectedUndoMoveScore(Move<Solution_> move,
                                        Score_ beforeMoveScore)
```
    Description copied from interface: InnerScoreDirector
    
    Asserts that if the Score is calculated for the current working solution in the current ScoreDirector (with incremental calculation residue), it is equal to the parameter beforeMoveScore.
    Furthermore, if the assert fails, a score corruption analysis might be included in the exception message.
    
    Specified by:
    
    assertExpectedUndoMoveScore in interface InnerScoreDirector<Solution_,Score_ extends Score<Score_>>
    
    Parameters:
    
    move - never null
    
    beforeMoveScore - never null
  - buildScoreCorruptionAnalysis
```
protected String buildScoreCorruptionAnalysis(InnerScoreDirector<Solution_,Score_> uncorruptedScoreDirector,
                                              boolean predicted)
```
    Parameters:
    
    uncorruptedScoreDirector - never null
    
    predicted - true if the score was predicted and might have been calculated on another thread
    
    Returns:
    
    never null
  - isConstraintConfiguration
```
protected boolean isConstraintConfiguration(Object problemFactOrEntity)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class AbstractScoreDirector<Solution_,​Score_ extends Score<Score_>,​Factory_ extends AbstractScoreDirectorFactory<Solution_,​Score_>>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface ai.timefold.solver.core.impl.score.director.InnerScoreDirector

Field Detail

logger

scoreDirectorFactory

lookUpEnabled

lookUpManager

expectShadowVariablesInCorrectState

variableListenerSupport

constraintMatchEnabledPreference

workingSolution

workingEntityListRevision

workingInitScore

allChangesWillBeUndoneBeforeStepEnds

calculationCount

Constructor Detail

AbstractScoreDirector

Method Detail

getScoreDirectorFactory

getSolutionDescriptor

getScoreDefinition

expectShadowVariablesInCorrectState

overwriteConstraintMatchEnabledPreference

getWorkingSolution

getWorkingEntityListRevision

setAllChangesWillBeUndoneBeforeStepEnds

getCalculationCount

resetCalculationCount

incrementCalculationCount

getSupplyManager

setWorkingSolution

assertNonNullPlanningIds

doAndProcessMove

doAndProcessMove

isWorkingEntityListDirty

setWorkingEntityListDirty

cloneWorkingSolution

cloneSolution

triggerVariableListeners

forceTriggerVariableListeners

setCalculatedScore

clone

createChildThreadScoreDirector

close

beforeEntityAdded

afterEntityAdded

beforeVariableChanged

afterVariableChanged

beforeListVariableElementAssigned

afterListVariableElementAssigned

beforeListVariableElementUnassigned

afterListVariableElementUnassigned

beforeListVariableChanged

afterListVariableChanged

beforeEntityRemoved

afterEntityRemoved

beforeEntityAdded

afterEntityAdded

beforeVariableChanged

afterVariableChanged

changeVariableFacade

beforeListVariableElementAssigned

afterListVariableElementAssigned

beforeListVariableElementUnassigned

afterListVariableElementUnassigned

beforeListVariableChanged

afterListVariableChanged

beforeEntityRemoved

afterEntityRemoved

beforeProblemFactAdded

afterProblemFactAdded

beforeProblemPropertyChanged

afterProblemPropertyChanged

beforeProblemFactRemoved

afterProblemFactRemoved

lookUpWorkingObject

Class AbstractScoreDirector<Solution_,Score_ extends Score<Score_>,Factory_ extends AbstractScoreDirectorFactory<Solution_,Score_>>