How to use

next

method

in

org.springframework.batch.core.step.item.Chunk$ChunkIterator

final I item = iterator.next();

List<O> items = Collections.singletonList(outputIterator.next());
inputIterator.next();
try {
  writeItems(items);

/**
 * @param chunk Chunk to recover
 */
private void recover(Chunk<String> chunk) throws Exception {
  for (Chunk<String>.ChunkIterator iterator = chunk.iterator(); iterator.hasNext();) {
    String string = iterator.next();
    try {
      doWrite(Collections.singletonList(string));
    } catch (Exception e) {
      iterator.remove(e);
      throw e;
    }
  }
}

final I item = iterator.next();

final I item = iterator.next();

final I item = iterator.next();

List<O> items = Collections.singletonList(outputIterator.next());
inputIterator.next();
try {
  writeItems(items);

List<O> items = Collections.singletonList(outputIterator.next());
inputIterator.next();
try {
  writeItems(items);

Chunk<O>.ChunkIterator outputIterator = outputs.iterator();
List<O> items = Collections.singletonList(outputIterator.next());
inputIterator.next();
try {
  writeItems(items);

Chunk<O>.ChunkIterator outputIterator = outputs.iterator();
List<O> items = Collections.singletonList(outputIterator.next());
inputIterator.next();
try {
  writeItems(items);

protected Chunk<O> transform(StepContribution contribution, Chunk<I> inputs) throws Exception {
  Chunk<O> outputs = new Chunk<O>();
  for (Chunk<I>.ChunkIterator iterator = inputs.iterator(); iterator.hasNext();) {
    final I item = iterator.next();
    O output;
    try {
      output = doProcess(item);
    }
    catch (Exception e) {
      /*
       * For a simple chunk processor (no fault tolerance) we are done
       * here, so prevent any more processing of these inputs.
       */
      inputs.clear();
      throw e;
    }
    if (output != null) {
      outputs.add(output);
    }
    else {
      iterator.remove();
    }
  }
  return outputs;
}

protected Chunk<O> transform(StepContribution contribution, Chunk<I> inputs) throws Exception {
  Chunk<O> outputs = new Chunk<O>();
  for (Chunk<I>.ChunkIterator iterator = inputs.iterator(); iterator.hasNext();) {
    final I item = iterator.next();
    O output;
    try {
      output = doProcess(item);
    }
    catch (Exception e) {
      /*
       * For a simple chunk processor (no fault tolerance) we are done
       * here, so prevent any more processing of these inputs.
       */
      inputs.clear();
      throw e;
    }
    if (output != null) {
      outputs.add(output);
    }
    else {
      iterator.remove();
    }
  }
  return outputs;
}

@Override
public Object recover(RetryContext context) throws Exception {
  Throwable e = context.getLastThrowable();
  if (outputs.size() > 1 && !rollbackClassifier.classify(e)) {
    throw new RetryException("Invalid retry state during write caused by "
        + "exception that does not classify for rollback: ", e);
  }
  Chunk<I>.ChunkIterator inputIterator = inputs.iterator();
  for (Chunk<O>.ChunkIterator outputIterator = outputs.iterator(); outputIterator.hasNext();) {
    inputIterator.next();
    outputIterator.next();
    checkSkipPolicy(inputIterator, outputIterator, e, contribution, true);
    if (!rollbackClassifier.classify(e)) {
      throw new RetryException(
          "Invalid retry state during recovery caused by exception that does not classify for rollback: ",
          e);
    }
  }
  return null;
}

@Override
public Object recover(RetryContext context) throws Exception {
  Throwable e = context.getLastThrowable();
  if (outputs.size() > 1 && !rollbackClassifier.classify(e)) {
    throw new RetryException("Invalid retry state during write caused by "
        + "exception that does not classify for rollback: ", e);
  }
  Chunk<I>.ChunkIterator inputIterator = inputs.iterator();
  for (Chunk<O>.ChunkIterator outputIterator = outputs.iterator(); outputIterator.hasNext();) {
    inputIterator.next();
    outputIterator.next();
    checkSkipPolicy(inputIterator, outputIterator, e, contribution, true);
    if (!rollbackClassifier.classify(e)) {
      throw new RetryException(
          "Invalid retry state during recovery caused by exception that does not classify for rollback: ",
          e);
    }
  }
  return null;
}

public Object recover(RetryContext context) throws Exception {
  Throwable e = context.getLastThrowable();
  if (outputs.size() > 1 && !rollbackClassifier.classify(e)) {
    throw new RetryException("Invalid retry state during write caused by "
        + "exception that does not classify for rollback: ", e);
  }
  Chunk<I>.ChunkIterator inputIterator = inputs.iterator();
  for (Chunk<O>.ChunkIterator outputIterator = outputs.iterator(); outputIterator.hasNext();) {
    inputIterator.next();
    outputIterator.next();
    checkSkipPolicy(inputIterator, outputIterator, e, contribution);
    if (!rollbackClassifier.classify(e)) {
      throw new RetryException(
          "Invalid retry state during recovery caused by exception that does not classify for rollback: ",
          e);
    }
  }
  return null;
}

protected Chunk<O> transform(StepContribution contribution, Chunk<I> inputs) throws Exception {
  Chunk<O> outputs = new Chunk<O>();
  for (Chunk<I>.ChunkIterator iterator = inputs.iterator(); iterator.hasNext();) {
    final I item = iterator.next();
    O output;
    try {
      output = doProcess(item);
    }
    catch (Exception e) {
      /*
       * For a simple chunk processor (no fault tolerance) we are done
       * here, so prevent any more processing of these inputs.
       */
      inputs.clear();
      throw e;
    }
    if (output != null) {
      outputs.add(output);
    }
    else {
      iterator.remove();
    }
  }
  return outputs;
}

@Override
public Object recover(RetryContext context) throws Exception {
  Throwable e = context.getLastThrowable();
  if (outputs.size() > 1 && !rollbackClassifier.classify(e)) {
    throw new RetryException("Invalid retry state during write caused by "
        + "exception that does not classify for rollback: ", e);
  }
  Chunk<I>.ChunkIterator inputIterator = inputs.iterator();
  for (Chunk<O>.ChunkIterator outputIterator = outputs.iterator(); outputIterator.hasNext();) {
    inputIterator.next();
    outputIterator.next();
    checkSkipPolicy(inputIterator, outputIterator, e, contribution, true);
    if (!rollbackClassifier.classify(e)) {
      throw new RetryException(
          "Invalid retry state during recovery caused by exception that does not classify for rollback: ",
          e);
    }
  }
  return null;
}

protected Chunk<O> transform(StepContribution contribution, Chunk<I> inputs) throws Exception {
  Chunk<O> outputs = new Chunk<O>();
  for (Chunk<I>.ChunkIterator iterator = inputs.iterator(); iterator.hasNext();) {
    final I item = iterator.next();
    O output = doProcess(item);
    if (output != null) {
      outputs.add(output);
    }
    else {
      iterator.remove();
    }
  }
  return outputs;
}

protected Chunk<O> transform(StepContribution contribution, Chunk<I> inputs) throws Exception {
  Chunk<O> outputs = new Chunk<>();
  for (Chunk<I>.ChunkIterator iterator = inputs.iterator(); iterator.hasNext();) {
    final I item = iterator.next();
    O output;
    try {
      output = doProcess(item);
    }
    catch (Exception e) {
      /*
       * For a simple chunk processor (no fault tolerance) we are done
       * here, so prevent any more processing of these inputs.
       */
      inputs.clear();
      throw e;
    }
    if (output != null) {
      outputs.add(output);
    }
    else {
      iterator.remove();
    }
  }
  return outputs;
}

@Override
public Object recover(RetryContext context) throws Exception {
  Throwable e = context.getLastThrowable();
  if (outputs.size() > 1 && !rollbackClassifier.classify(e)) {
    throw new RetryException("Invalid retry state during write caused by "
        + "exception that does not classify for rollback: ", e);
  }
  Chunk<I>.ChunkIterator inputIterator = inputs.iterator();
  for (Chunk<O>.ChunkIterator outputIterator = outputs.iterator(); outputIterator.hasNext();) {
    inputIterator.next();
    outputIterator.next();
    checkSkipPolicy(inputIterator, outputIterator, e, contribution, true);
    if (!rollbackClassifier.classify(e)) {
      throw new RetryException(
          "Invalid retry state during recovery caused by exception that does not classify for rollback: ",
          e);
    }
  }
  return null;
}