Package org.optaplanner.core.impl.phase

## Class AbstractPhase<Solution_>

- java.lang.Object
- - org.optaplanner.core.impl.phase.AbstractPhase<Solution_>

- Type Parameters:
    `Solution_` - the solution type, the class with the `PlanningSolution` annotation
  All Implemented Interfaces:
    `EventListener`, `PhaseLifecycleListener<Solution_>`, `Phase<Solution_>`, `SolverLifecycleListener<Solution_>`
  Direct Known Subclasses:
    `DefaultConstructionHeuristicPhase`, `DefaultCustomPhase`, `DefaultExhaustiveSearchPhase`, `DefaultLocalSearchPhase`, `DefaultPartitionedSearchPhase`, `NoChangePhase`

      public abstract class AbstractPhase<Solution_>
      extends Object
      implements Phase<Solution_>

  See Also:
    `DefaultLocalSearchPhase`

- - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `protected boolean` | `assertExpectedStepScore` |
    `protected boolean` | `assertShadowVariablesAreNotStaleAfterStep` |
    `protected boolean` | `assertStepScoreFromScratch` |
    `protected BestSolutionRecaller<Solution_>` | `bestSolutionRecaller` |
    `protected org.slf4j.Logger` | `logger` |
    `protected String` | `logIndentation` |
    `protected int` | `phaseIndex` |
    `protected PhaseLifecycleSupport<Solution_>` | `phaseLifecycleSupport` | Used for `addPhaseLifecycleListener(PhaseLifecycleListener)`.
    `protected PhaseLifecycleSupport<Solution_>` | `solverPhaseLifecycleSupport` | Used for `AbstractSolver.addPhaseLifecycleListener(PhaseLifecycleListener)`.
    `protected Termination<Solution_>` | `termination` |

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `AbstractPhase​(int phaseIndex, String logIndentation, BestSolutionRecaller<Solution_> bestSolutionRecaller, Termination<Solution_> termination)` |

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `addPhaseLifecycleListener​(PhaseLifecycleListener<Solution_> phaseLifecycleListener)` | Add a `PhaseLifecycleListener` that is only notified of the `phase` and the `PhaseLifecycleListener.stepStarted(AbstractStepScope)` step} starting/ending events from this phase (and the `SolverLifecycleListener.solvingStarted(SolverScope)` solving} events too of course).
    `protected void` | `assertWorkingSolutionInitialized​(AbstractPhaseScope<Solution_> phaseScope)` |
    `protected <Score_ extends Score<Score_>> void` | `calculateWorkingStepScore​(AbstractStepScope<Solution_> stepScope, Object completedAction)` |
    `int` | `getPhaseIndex()` |
    `abstract String` | `getPhaseTypeString()` |
    `Termination<Solution_>` | `getTermination()` |
    `boolean` | `isAssertExpectedStepScore()` |
    `boolean` | `isAssertShadowVariablesAreNotStaleAfterStep()` |
    `boolean` | `isAssertStepScoreFromScratch()` |
    `void` | `phaseEnded​(AbstractPhaseScope<Solution_> phaseScope)` |
    `void` | `phaseStarted​(AbstractPhaseScope<Solution_> phaseScope)` |
    `protected <Score_ extends Score<Score_>> void` | `predictWorkingStepScore​(AbstractStepScope<Solution_> stepScope, Object completedAction)` |
    `void` | `removePhaseLifecycleListener​(PhaseLifecycleListener<Solution_> phaseLifecycleListener)` |
    `void` | `setAssertExpectedStepScore​(boolean assertExpectedStepScore)` |
    `void` | `setAssertShadowVariablesAreNotStaleAfterStep​(boolean assertShadowVariablesAreNotStaleAfterStep)` |
    `void` | `setAssertStepScoreFromScratch​(boolean assertStepScoreFromScratch)` |
    `void` | `setSolverPhaseLifecycleSupport​(PhaseLifecycleSupport<Solution_> solverPhaseLifecycleSupport)` | Used to make `AbstractSolver.addPhaseLifecycleListener(PhaseLifecycleListener)` work.
    `void` | `solvingEnded​(SolverScope<Solution_> solverScope)` |
    `void` | `solvingStarted​(SolverScope<Solution_> solverScope)` |
    `void` | `stepEnded​(AbstractStepScope<Solution_> stepScope)` |
    `void` | `stepStarted​(AbstractStepScope<Solution_> stepScope)` |

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface org.optaplanner.core.impl.phase.Phase

      `solve`

- - ### Field Detail

    - #### logger

          protected final transient org.slf4j.Logger logger

    - #### phaseIndex

          protected final int phaseIndex

    - #### logIndentation

          protected final String logIndentation

    - #### bestSolutionRecaller

          protected final BestSolutionRecaller<Solution_> bestSolutionRecaller

    - #### termination

          protected final Termination<Solution_> termination

    - #### solverPhaseLifecycleSupport

          protected PhaseLifecycleSupport<Solution_> solverPhaseLifecycleSupport

      Used for `AbstractSolver.addPhaseLifecycleListener(PhaseLifecycleListener)`.

    - #### phaseLifecycleSupport

          protected PhaseLifecycleSupport<Solution_> phaseLifecycleSupport

      Used for `addPhaseLifecycleListener(PhaseLifecycleListener)`.

    - #### assertStepScoreFromScratch

          protected boolean assertStepScoreFromScratch

    - #### assertExpectedStepScore

          protected boolean assertExpectedStepScore

    - #### assertShadowVariablesAreNotStaleAfterStep

          protected boolean assertShadowVariablesAreNotStaleAfterStep

  - ### Constructor Detail

    - #### AbstractPhase

          public AbstractPhase​(int phaseIndex,
                               String logIndentation,
                               BestSolutionRecaller<Solution_> bestSolutionRecaller,
                               Termination<Solution_> termination)

  - ### Method Detail

    - #### getPhaseIndex

          public int getPhaseIndex()

    - #### getTermination

          public Termination<Solution_> getTermination()

    - #### setSolverPhaseLifecycleSupport

          public void setSolverPhaseLifecycleSupport​(PhaseLifecycleSupport<Solution_> solverPhaseLifecycleSupport)

      Description copied from interface: `Phase`
      Used to make `AbstractSolver.addPhaseLifecycleListener(PhaseLifecycleListener)` work.
      Specified by:
        `setSolverPhaseLifecycleSupport` in interface `Phase<Solution_>`
      Parameters:
        `solverPhaseLifecycleSupport` - never null

    - #### isAssertStepScoreFromScratch

          public boolean isAssertStepScoreFromScratch()

    - #### setAssertStepScoreFromScratch

          public void setAssertStepScoreFromScratch​(boolean assertStepScoreFromScratch)

    - #### isAssertExpectedStepScore

          public boolean isAssertExpectedStepScore()

    - #### setAssertExpectedStepScore

          public void setAssertExpectedStepScore​(boolean assertExpectedStepScore)

    - #### isAssertShadowVariablesAreNotStaleAfterStep

          public boolean isAssertShadowVariablesAreNotStaleAfterStep()

    - #### setAssertShadowVariablesAreNotStaleAfterStep

          public void setAssertShadowVariablesAreNotStaleAfterStep​(boolean assertShadowVariablesAreNotStaleAfterStep)

    - #### getPhaseTypeString

          public abstract String getPhaseTypeString()

    - #### solvingStarted

          public void solvingStarted​(SolverScope<Solution_> solverScope)

      Specified by:
        `solvingStarted` in interface `SolverLifecycleListener<Solution_>`

    - #### solvingEnded

          public void solvingEnded​(SolverScope<Solution_> solverScope)

      Specified by:
        `solvingEnded` in interface `SolverLifecycleListener<Solution_>`

    - #### phaseStarted

          public void phaseStarted​(AbstractPhaseScope<Solution_> phaseScope)

      Specified by:
        `phaseStarted` in interface `PhaseLifecycleListener<Solution_>`

    - #### stepStarted

          public void stepStarted​(AbstractStepScope<Solution_> stepScope)

      Specified by:
        `stepStarted` in interface `PhaseLifecycleListener<Solution_>`

    - #### calculateWorkingStepScore

          protected <Score_ extends Score<Score_>> void calculateWorkingStepScore​(AbstractStepScope<Solution_> stepScope,
                                                                                  Object completedAction)

    - #### predictWorkingStepScore

          protected <Score_ extends Score<Score_>> void predictWorkingStepScore​(AbstractStepScope<Solution_> stepScope,
                                                                                Object completedAction)

    - #### stepEnded

          public void stepEnded​(AbstractStepScope<Solution_> stepScope)

      Specified by:
        `stepEnded` in interface `PhaseLifecycleListener<Solution_>`

    - #### phaseEnded

          public void phaseEnded​(AbstractPhaseScope<Solution_> phaseScope)

      Specified by:
        `phaseEnded` in interface `PhaseLifecycleListener<Solution_>`

    - #### addPhaseLifecycleListener

          public void addPhaseLifecycleListener​(PhaseLifecycleListener<Solution_> phaseLifecycleListener)

      Description copied from interface: `Phase`
      Add a `PhaseLifecycleListener` that is only notified of the `phase` and the `PhaseLifecycleListener.stepStarted(AbstractStepScope)` step} starting/ending events from this phase (and the `SolverLifecycleListener.solvingStarted(SolverScope)` solving} events too of course).

      To get notified for all phases, use `AbstractSolver.addPhaseLifecycleListener(PhaseLifecycleListener)` instead.

      Specified by:
        `addPhaseLifecycleListener` in interface `Phase<Solution_>`
      Parameters:
        `phaseLifecycleListener` - never null

    - #### removePhaseLifecycleListener

          public void removePhaseLifecycleListener​(PhaseLifecycleListener<Solution_> phaseLifecycleListener)

      Specified by:
        `removePhaseLifecycleListener` in interface `Phase<Solution_>`
      Parameters:
        `phaseLifecycleListener` - never null
      See Also:
        `Phase.addPhaseLifecycleListener(PhaseLifecycleListener)`

    - #### assertWorkingSolutionInitialized

          protected void assertWorkingSolutionInitialized​(AbstractPhaseScope<Solution_> phaseScope)