Package ghidra.app.util

# Class DecompilerConcurrentQ<I,R>

java.lang.Object
ghidra.app.util.DecompilerConcurrentQ<I,R>

Type Parameters:
  `I` - The input data needed by the supplied `QCallback`
  `R` - The result data (can be the same as `I` if there is no result) returned by the `QCallback.process(Object, TaskMonitor)` method.

public class DecompilerConcurrentQ<I,R> extends Object
A class to perform some of the boilerplate setup of the `ConcurrentQ` that is shared amongst clients that perform decompilation in parallel.

This class can be used in a blocking or non-blocking fashion.

- For blocking usage, call one of the `add` methods to put items in the queue and then call `waitForResults()`.
- For non-blocking usage, simply call `process(Iterator, Consumer)`, passing the consumer of the results.

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `DecompilerConcurrentQ(QCallback<I,R> callback, GThreadPool pool, boolean collectResults, TaskMonitor monitor)`
  `DecompilerConcurrentQ(QCallback<I,R> callback, TaskMonitor monitor)`
  `DecompilerConcurrentQ(QCallback<I,R> callback, String threadPoolName, TaskMonitor monitor)`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `add(I i)`
  `void`
  `addAll(Collection<I> collection)`
  `void`
  `addAll(Iterator<I> iterator)`
  `void`
  `dispose()`
  `void`
  `dispose(long timeoutSeconds)`
  Calls dispose on the queue being processed.
  `void`
  `process(Iterator<I> functions, Consumer<R> consumer)`
  Adds all items to the queue for processing.
  `Collection<QResult<I,R>>`
  `waitForResults()`
  Waits for all results to be delivered.
  `void`
  `waitUntilDone()`
  Waits for all work to finish.

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

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

- ## Constructor Details

  - ### DecompilerConcurrentQ

    public DecompilerConcurrentQ(QCallback<I,R> callback, TaskMonitor monitor)

  - ### DecompilerConcurrentQ

    public DecompilerConcurrentQ(QCallback<I,R> callback, String threadPoolName, TaskMonitor monitor)

  - ### DecompilerConcurrentQ

    public DecompilerConcurrentQ(QCallback<I,R> callback, GThreadPool pool, boolean collectResults, TaskMonitor monitor)

- ## Method Details

  - ### addAll

    public void addAll(Collection<I> collection)

  - ### addAll

    public void addAll(Iterator<I> iterator)

  - ### add

    public void add(I i)

  - ### process

    public void process(Iterator<I> functions, Consumer<R> consumer)
    Adds all items to the queue for processing. The results will be passed to the given consumer as they are produced.
    Parameters:
      `functions` - the functions to process
      `consumer` - the results consumer

  - ### waitForResults

    public Collection<QResult<I,R>> waitForResults() throws InterruptedException
    Waits for all results to be delivered. The client is responsible for processing the results and handling any exceptions that may have occurred.
    Returns:
      all results
    Throws:
      `InterruptedException` - if interrupted while waiting

  - ### waitUntilDone

    public void waitUntilDone() throws InterruptedException, Exception
    Waits for all work to finish. Any exception encountered will trigger all processing to stop. If you wish for the work to continue despite exceptions, then use `waitForResults()`.
    Throws:
      `InterruptedException` - if interrupted while waiting
      `Exception` - any exception that is encountered while processing items.

  - ### dispose

    public void dispose()

  - ### dispose

    public void dispose(long timeoutSeconds)
    Calls dispose on the queue being processed. Further, the call will block for up to `timeoutSeconds` while waiting for the queue to finish processing.
    Parameters:
      `timeoutSeconds` - the number of seconds to wait for the disposed queue to finish processing