How to use org.apache.taverna.workflowmodel.processor.dispatch.events

@Override
public DispatchJobEvent pushOwningProcess(String localProcessName)
    throws ProcessIdentifierException {
  return new DispatchJobEvent(pushOwner(localProcessName), index,
      context, dataMap, activities);
}

@Override
public DispatchJobQueueEvent pushOwningProcess(String localProcessName)
    throws ProcessIdentifierException {
  return new DispatchJobQueueEvent(pushOwner(localProcessName), context,
      queue, activities);
}

@Override
public DispatchResultEvent pushOwningProcess(String localProcessName)
    throws ProcessIdentifierException {
  return new DispatchResultEvent(pushOwner(localProcessName), index,
      context, dataMap, streaming);
}

@Override
public void receiveError(DispatchErrorEvent errorEvent) {
  logger.error("Error received in dispatch stack on owningProcess:"
      + errorEvent.getOwningProcess() + ", msg:"
      + errorEvent.getMessage(), errorEvent.getCause());
  if (errorEvent.getIndex().length == 0)
    sendCachePurge(errorEvent.getOwningProcess());
}

/**
 * If we see a result with an index matching one of those in the current
 * retry state we can safely forget that state object
 */
@Override
public void receiveResult(DispatchResultEvent j) {
  forget(j.getOwningProcess(), j.getIndex());
  getAbove().receiveResult(j);
}

/**
 * If an error occurs we can either handle the error or send it to the layer
 * above for further processing.
 */
@Override
public void receiveError(DispatchErrorEvent errorEvent) {
  String owningProcess = errorEvent.getOwningProcess();
  for (JobState rs : getJobsCopy(owningProcess))
    if (identicalIndex(rs.jobEvent.getIndex(), errorEvent.getIndex())) {
      boolean handled = rs.handleError();
      if (!handled) {
        removeJob(owningProcess, rs);
        getAbove().receiveError(errorEvent);
        return;
      }
    }
}

@Override
public void fail(String message, Throwable t,
    DispatchErrorType errorType) {
  logger.warn("Failed (" + errorType + ") invoking " + activity
      + " for job " + jobEvent + ": " + message, t);
  monMan.deregisterNode(
      invocationProcessIdentifier);
  getAbove().receiveError(
      new DispatchErrorEvent(jobEvent.getOwningProcess(),
          jobEvent.getIndex(), jobEvent.getContext(),
          message, t, errorType, activity));
}

@Override
public void fail(String message, Throwable t,
    DispatchErrorType errorType) {
  logger.warn("Failed (" + errorType + ") invoking condition service "
      + jobIdentifier + ":" + message, t);
  AbstractDispatchEvent originalEvent;
  synchronized (incomingJobs) {
    originalEvent = incomingJobs.get(jobIdentifier);
  }
  receiveError(new DispatchErrorEvent(originalEvent
      .getOwningProcess(), originalEvent.getIndex(),
      originalEvent.getContext(),
      "Can't invoke condition service ", t,
      DispatchErrorType.INVOCATION, null));
}

@Override
public DispatchErrorEvent pushOwningProcess(String localProcessName)
    throws ProcessIdentifierException {
  return new DispatchErrorEvent(pushOwner(localProcessName), index,
      context, message, cause, failureType, failedActivity);
}

@Override
public DispatchJobEvent popOwningProcess()
    throws ProcessIdentifierException {
  return new DispatchJobEvent(popOwner(), index, context, dataMap,
      activities);
}

@Override
public DispatchResultEvent popOwningProcess()
    throws ProcessIdentifierException {
  return new DispatchResultEvent(popOwner(), index, context, dataMap,
      streaming);
}

@Override
public DispatchCompletionEvent popOwningProcess()
    throws ProcessIdentifierException {
  return new DispatchCompletionEvent(popOwner(), index, context);
}

@Override
public DispatchJobQueueEvent popOwningProcess()
    throws ProcessIdentifierException {
  return new DispatchJobQueueEvent(popOwner(), context, queue, activities);
}

@Override
public DispatchErrorEvent popOwningProcess()
    throws ProcessIdentifierException {
  return new DispatchErrorEvent(popOwner(), index, context, message,
      cause, failureType, failedActivity);
}

@Override
public DispatchCompletionEvent pushOwningProcess(String localProcessName)
    throws ProcessIdentifierException {
  return new DispatchCompletionEvent(pushOwner(localProcessName), index,
      context);
}

private Map<String, T2Reference> getOutData(String jobIdentifier) {
  AbstractDispatchEvent outEvent;
  synchronized (outgoingJobs) {
    outEvent = outgoingJobs.get(jobIdentifier);
  }
  Map<String, T2Reference> outData = new HashMap<>();
  if (outEvent instanceof DispatchResultEvent)
    outData = ((DispatchResultEvent) outEvent).getData();
  return outData;
}

public ConditionCallBack(String jobIdentifier) {
  this.jobIdentifier = jobIdentifier;
  AbstractDispatchEvent originalEvent;
  synchronized (incomingJobs) {
    originalEvent = incomingJobs.get(jobIdentifier);
  }
  context = originalEvent.getContext();
  processId = originalEvent.getOwningProcess() + ":condition";
}

private String jobIdentifier(AbstractDispatchEvent event) {
  String jobId = event.getOwningProcess()
      + Arrays.toString(event.getIndex());
  return jobId;
}

@Override
public InvocationContext getContext() {
  return jobEvent.getContext();
}

Integer queueSize() {
  return queueEvent.getQueue().size();
}