Package org.optaplanner.core.impl.heuristic.thread

## Class OrderByMoveIndexBlockingQueue<Solution_>

- java.lang.Object
- - org.optaplanner.core.impl.heuristic.thread.OrderByMoveIndexBlockingQueue<Solution_>

-     public class OrderByMoveIndexBlockingQueue<Solution_>
      extends Object

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class | Description
    --- | --- | ---
    `static class` | `OrderByMoveIndexBlockingQueue.MoveResult<Solution_>` |

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `OrderByMoveIndexBlockingQueue​(int capacity)` |

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `addExceptionThrown​(int moveThreadIndex, Throwable throwable)` | This method is thread-safe.
    `void` | `addMove​(int moveThreadIndex, int stepIndex, int moveIndex, Move<Solution_> move, Score score)` | This method is thread-safe.
    `void` | `addUndoableMove​(int moveThreadIndex, int stepIndex, int moveIndex, Move<Solution_> move)` | This method is thread-safe.
    `void` | `startNextStep​(int stepIndex)` | Not thread-safe.
    `OrderByMoveIndexBlockingQueue.MoveResult<Solution_>` | `take()` | Not thread-safe.

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

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

- - ### Constructor Detail

    - #### OrderByMoveIndexBlockingQueue

          public OrderByMoveIndexBlockingQueue​(int capacity)

  - ### Method Detail

    - #### startNextStep

          public void startNextStep​(int stepIndex)

      Not thread-safe. Can only be called from the solver thread.
      Parameters:
        `stepIndex` - at least 0

    - #### addUndoableMove

          public void addUndoableMove​(int moveThreadIndex,
                                      int stepIndex,
                                      int moveIndex,
                                      Move<Solution_> move)

      This method is thread-safe. It can be called from any move thread.
      Parameters:
        `moveThreadIndex` - `0 <= moveThreadIndex < moveThreadCount`
        `stepIndex` - at least 0
        `moveIndex` - at least 0
        `move` - never null
      See Also:
        `BlockingQueue.add(Object)`

    - #### addMove

          public void addMove​(int moveThreadIndex,
                              int stepIndex,
                              int moveIndex,
                              Move<Solution_> move,
                              Score score)

      This method is thread-safe. It can be called from any move thread.
      Parameters:
        `moveThreadIndex` - `0 <= moveThreadIndex < moveThreadCount`
        `stepIndex` - at least 0
        `moveIndex` - at least 0
        `move` - never null
        `score` - never null
      See Also:
        `BlockingQueue.add(Object)`

    - #### addExceptionThrown

          public void addExceptionThrown​(int moveThreadIndex,
                                         Throwable throwable)

      This method is thread-safe. It can be called from any move thread. Previous results (that haven't been consumed yet), will still be returned during iteration before the iteration throws an exception, unless there's a lower moveIndex that isn't in the queue yet.
      Parameters:
        `moveThreadIndex` - `0 <= moveThreadIndex < moveThreadCount`
        `throwable` - never null

    - #### take

          public OrderByMoveIndexBlockingQueue.MoveResult<Solution_> take()
                                                                   throws InterruptedException

      Not thread-safe. Can only be called from the solver thread.
      Returns:
        never null
      Throws:
        `InterruptedException` - if interrupted
      See Also:
        `BlockingQueue.take()`