org.optaplanner.core.impl.heuristic.selector.move.generic.chained

## Class ChainedSwapMove<Solution_>

- java.lang.Object
- - org.optaplanner.core.impl.heuristic.move.AbstractMove<Solution_>
  - - org.optaplanner.core.impl.heuristic.selector.move.generic.SwapMove<Solution_>
    - - org.optaplanner.core.impl.heuristic.selector.move.generic.chained.ChainedSwapMove<Solution_>

- Type Parameters:
    `Solution_` - the solution type, the class with the `PlanningSolution` annotation
  All Implemented Interfaces:
    Move<Solution_>

      public class ChainedSwapMove<Solution_>
      extends SwapMove<Solution_>

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected List<Object>` | `oldLeftTrailingEntityList`
    `protected List<Object>` | `oldRightTrailingEntityList`

    - ### Fields inherited from class org.optaplanner.core.impl.heuristic.selector.move.generic.SwapMove

      `leftEntity, rightEntity, variableDescriptorList`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ChainedSwapMove(List<GenuineVariableDescriptor<Solution_>> variableDescriptorList, List<SingletonInverseVariableSupply> inverseVariableSupplyList, Object leftEntity, Object rightEntity)`
    `ChainedSwapMove(List<GenuineVariableDescriptor<Solution_>> genuineVariableDescriptors, Object leftEntity, Object rightEntity, List<Object> oldLeftTrailingEntityList, List<Object> oldRightTrailingEntityList)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `ChainedSwapMove<Solution_>` | `createUndoMove(ScoreDirector<Solution_> scoreDirector)` Called before the move is done, so the move can be evaluated and then be undone without resulting into a permanent change in the solution.
    `protected void` | `doMoveOnGenuineVariables(ScoreDirector<Solution_> scoreDirector)` Like `AbstractMove.doMove(ScoreDirector)` but without the `ScoreDirector.triggerVariableListeners()` call (because `AbstractMove.doMove(ScoreDirector)` already does that).
    `ChainedSwapMove<Solution_>` | `rebase(ScoreDirector<Solution_> destinationScoreDirector)` Rebases a move from an origin `ScoreDirector` to another destination `ScoreDirector` which is usually on another `Thread` or JVM.

    - ### Methods inherited from class org.optaplanner.core.impl.heuristic.selector.move.generic.SwapMove

      `appendVariablesToString, equals, getLeftEntity, getPlanningEntities, getPlanningValues, getRightEntity, getSimpleMoveTypeDescription, getVariableNameList, hashCode, isMoveDoable, toString`

    - ### Methods inherited from class org.optaplanner.core.impl.heuristic.move.AbstractMove

      `doMove, rebaseArray, rebaseList`

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

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### oldLeftTrailingEntityList

          protected final List<Object> oldLeftTrailingEntityList

    - #### oldRightTrailingEntityList

          protected final List<Object> oldRightTrailingEntityList

  - ### Constructor Detail

    - #### ChainedSwapMove

          public ChainedSwapMove(List<GenuineVariableDescriptor<Solution_>> variableDescriptorList,
                                 List<SingletonInverseVariableSupply> inverseVariableSupplyList,
                                 Object leftEntity,
                                 Object rightEntity)

    - #### ChainedSwapMove

          public ChainedSwapMove(List<GenuineVariableDescriptor<Solution_>> genuineVariableDescriptors,
                                 Object leftEntity,
                                 Object rightEntity,
                                 List<Object> oldLeftTrailingEntityList,
                                 List<Object> oldRightTrailingEntityList)

  - ### Method Detail

    - #### createUndoMove

          public ChainedSwapMove<Solution_> createUndoMove(ScoreDirector<Solution_> scoreDirector)

      Description copied from class: `AbstractMove`
      Called before the move is done, so the move can be evaluated and then be undone without resulting into a permanent change in the solution.
      Overrides:
        `createUndoMove` in class `SwapMove<Solution_>`
      Parameters:
        `scoreDirector` - the `ScoreDirector` not yet modified by the move.
      Returns:
        an undoMove which does the exact opposite of this move.

    - #### doMoveOnGenuineVariables

          protected void doMoveOnGenuineVariables(ScoreDirector<Solution_> scoreDirector)

      Description copied from class: `AbstractMove`
      Like `AbstractMove.doMove(ScoreDirector)` but without the `ScoreDirector.triggerVariableListeners()` call (because `AbstractMove.doMove(ScoreDirector)` already does that).
      Overrides:
        `doMoveOnGenuineVariables` in class `SwapMove<Solution_>`
      Parameters:
        `scoreDirector` - never null

    - #### rebase

          public ChainedSwapMove<Solution_> rebase(ScoreDirector<Solution_> destinationScoreDirector)

      Description copied from interface: `Move`
      Rebases a move from an origin `ScoreDirector` to another destination `ScoreDirector` which is usually on another `Thread` or JVM. The new move returned by this method translates the entities and problem facts to the destination `PlanningSolution` of the destination `ScoreDirector`, That destination `PlanningSolution` is a deep planning clone (or an even deeper clone) of the origin `PlanningSolution` that this move has been generated from.

      That new move does the exact same change as this move, resulting in the same `PlanningSolution` state, presuming that destination `PlanningSolution` was in the same state as the original `PlanningSolution` to begin with.

      Generally speaking, an implementation of this method iterates through every entity and fact instance in this move, translates each one to the destination `ScoreDirector` with `ScoreDirector.lookUpWorkingObject(Object)` and creates a new move instance of the same move type, using those translated instances.

      The destination `PlanningSolution` can be in a different state than the original `PlanningSolution`. So, rebasing can only depend on the identity of `planning entities` and planning facts, which is usually declared by a `PlanningId` on those classes. It must not depend on the state of the `planning variables`. One thread might rebase a move before, amid or after another thread does that same move instance.

      This method is thread-safe.

      Specified by:
        `rebase` in interface `Move<Solution_>`
      Overrides:
        `rebase` in class `SwapMove<Solution_>`
      Parameters:
        `destinationScoreDirector` - never null, the `ScoreDirector.getWorkingSolution()` that the new move should change the planning entity instances of.
      Returns:
        never null, a new move that does the same change as this move on another solution instance

Copyright © 2006–2020 JBoss by Red Hat. All rights reserved.