org.optaplanner.core.impl.score.director

Interface ScoreDirector<Solution_>

Type Parameters:

Solution_ - the solution type, the class with the PlanningSolution annotation

All Known Subinterfaces:

InnerScoreDirector<Solution_>

All Known Implementing Classes:

AbstractScoreDirector, DroolsScoreDirector, EasyScoreDirector, IncrementalScoreDirector

public interface ScoreDirector<Solution_>

The ScoreDirector holds the working solution and calculates the Score for it.

Method Summary

Modifier and Type	Method and Description
void	afterEntityAdded(Object entity)
void	afterEntityRemoved(Object entity)
void	afterProblemFactAdded(Object problemFact)
void	afterProblemFactChanged(Object problemFact)
void	afterProblemFactRemoved(Object problemFact)
void	afterVariableChanged(Object entity, String variableName)
void	afterVariableChanged(VariableDescriptor variableDescriptor, Object entity)
void	beforeEntityAdded(Object entity)
void	beforeEntityRemoved(Object entity)
void	beforeProblemFactAdded(Object problemFact)
void	beforeProblemFactChanged(Object problemFact)
void	beforeProblemFactRemoved(Object problemFact)
void	beforeVariableChanged(Object entity, String variableName)
void	beforeVariableChanged(VariableDescriptor variableDescriptor, Object entity)
Score	calculateScore() Calculates the Score and updates the working solution accordingly.
void	changeVariableFacade(VariableDescriptor variableDescriptor, Object entity, Object newValue)
void	dispose() Needs to be called after use because some implementations needs to clean up their resources.
Collection<ConstraintMatchTotal>	getConstraintMatchTotals()
Solution_	getWorkingSolution() The PlanningSolution that is used to calculate the Score.
boolean	isConstraintMatchEnabled()
void	setWorkingSolution(Solution_ workingSolution) The working solution must never be the same instance as the best solution, it should be a (un)changed clone.
void	triggerVariableListeners()

Method Detail

getWorkingSolution

Solution_ getWorkingSolution()

The PlanningSolution that is used to calculate the Score.

Because a Score is best calculated incrementally (by delta's), the ScoreDirector needs to be notified when it's working solution changes.

If the working solution has been changed since calculateScore() has been called, its Score won't be correct.

Returns:

never null

setWorkingSolution

void setWorkingSolution(Solution_ workingSolution)

The working solution must never be the same instance as the best solution, it should be a (un)changed clone.

Only call this method on a separate ScoreDirector instance, build by Solver.getScoreDirectorFactory(), not on the one used inside the Solver itself.

Parameters:

workingSolution - never null

calculateScore

Score calculateScore()

Calculates the Score and updates the working solution accordingly.

Returns:

never null, the Score of the working solution

isConstraintMatchEnabled

boolean isConstraintMatchEnabled()

Returns:

true if getConstraintMatchTotals() can be called

getConstraintMatchTotals

Collection<ConstraintMatchTotal> getConstraintMatchTotals()

Returns:

never null

Throws:

IllegalStateException - if isConstraintMatchEnabled() returns false

beforeEntityAdded

void beforeEntityAdded(Object entity)

afterEntityAdded

void afterEntityAdded(Object entity)

beforeVariableChanged

void beforeVariableChanged(Object entity,
                           String variableName)

afterVariableChanged

void afterVariableChanged(Object entity,
                          String variableName)

beforeVariableChanged

void beforeVariableChanged(VariableDescriptor variableDescriptor,
                           Object entity)

afterVariableChanged

void afterVariableChanged(VariableDescriptor variableDescriptor,
                          Object entity)

changeVariableFacade

void changeVariableFacade(VariableDescriptor variableDescriptor,
                          Object entity,
                          Object newValue)

triggerVariableListeners

void triggerVariableListeners()

beforeEntityRemoved

void beforeEntityRemoved(Object entity)

afterEntityRemoved

void afterEntityRemoved(Object entity)

beforeProblemFactAdded

void beforeProblemFactAdded(Object problemFact)

afterProblemFactAdded

void afterProblemFactAdded(Object problemFact)

beforeProblemFactChanged

void beforeProblemFactChanged(Object problemFact)

afterProblemFactChanged

void afterProblemFactChanged(Object problemFact)

beforeProblemFactRemoved

void beforeProblemFactRemoved(Object problemFact)

afterProblemFactRemoved

void afterProblemFactRemoved(Object problemFact)

dispose

void dispose()

Needs to be called after use because some implementations needs to clean up their resources.