How to use org.esa.snap.utils

  @Override
  public void run() {
    AdapterWatcher.INSTANCE.stopMonitor();
  }
}

  public IntMatrix runTilesInParallel(int threadCount, Executor threadPool) throws Exception {
    super.executeInParallel(threadCount, threadPool);

    return this.result;
  }
}

  public Int2ObjectMap<PixelSourceBands> computeCellsInParallel(int threadCount, Executor threadPool) throws Exception {
    super.executeInParallel(threadCount, threadPool);
    return this.validStatistics;
  }
}

@Override
protected final void runTile(int localRowIndex, int localColumnIndex) throws IOException, IllegalAccessException, InterruptedException {
  int localTileLeftX = localColumnIndex * getTileWidth();
  int localTileTopY = localRowIndex * getTileHeight();
  int localTileWidth = getTileWidth();
  int localTileHeight = getTileHeight();
  if (localTileLeftX + localTileWidth > getImageWidth()) {
    localTileWidth = getImageWidth() - localTileLeftX;
  }
  if (localTileTopY + localTileHeight > getImageHeight()) {
    localTileHeight = getImageHeight() - localTileTopY;
  }
  runTile(localTileLeftX, localTileTopY, localTileWidth, localTileHeight, localRowIndex, localColumnIndex);
}

  public void clearItems() {
    removeRange(0, size());
  }
}

public int getEdgeCount() {
  return this.edges.size();
}

public final long readLong() throws IOException {
  //return ((long)(readInt()) << 32) + (readInt() & 0xFFFFFFFFL);
  return ((long)(readInt()) << 32) | (readInt() & 0xFFFFFFFFL);
}

protected Node(int id, BoundingBox box, Contour contour, int perimeter, int area, int numberOfComponentsPerPixel) {
  this.id = id;
  this.edges = new ArrayListExtended<Edge>(0);
  this.means = new float[numberOfComponentsPerPixel];
  this.contour = contour;
  // merged = true => force to compute costs for the first iteration
  this.flags = VALID_FLAG | MERGED_FLAG;
  this.area = area;
  this.perimeter = perimeter;
  this.box = box;
}

  StorageMatrix computeMatrixCellsInParallel(int threadCount, Executor threadPool) throws Exception {
    super.executeInParallel(threadCount, threadPool);
    return this.storageMatrix;
  }
}

private static String separateWords(String text) {
  return separateWords(text, true);
}

public Node getNodeAt(int index) {
  return this.nodes.get(index);
}

public static void addPromptSupport(JComponent component, Property property) {
  addPromptSupport(component, property, null);
}

/**
 * Calls a method on the given object instance with the given argument.
 *
 * @param instance      the object instance
 * @param methodName    the name of the method to invoke
 * @param arg           the argument to pass to the method
 * @see PrivilegedAccessor#invokeMethod(Object,String,Object[])
 */
public static Object invokeMethod(Object instance, String methodName, Object arg)
    throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
  Object[] args = new Object[1];
  args[0] = arg;
  return invokeMethod(instance, methodName, args);
}

public void addNodes(Graph subgraph) {
  this.nodes.addAll(subgraph.nodes);
}

public void addNode(Node nodeToAdd) {
  this.nodes.add(nodeToAdd);
}

  public Int2ObjectMap<PixelStatistic> runTilesInParallel(int threadCount, Executor threadPool) throws Exception {
    super.executeInParallel(threadCount, threadPool);

    return this.statistics;
  }
}

public int getNodeCount() {
  return this.nodes.size();
}

public Graph(int numberOfNodes) {
  this.nodes = new ArrayListExtended<>(numberOfNodes);
}

  public ProductData runTilesInParallel(int threadCount, Executor threadPool) throws Exception {
    super.executeInParallel(threadCount, threadPool);

    return this.productData;
  }
}

public final Path runTilesInParallel(int threadCount, Executor threadPool) throws Exception {
  super.executeInParallel(threadCount, threadPool);
  return this.temporaryFolder;
}