How to use org.jbpm.workflow.core.node

@Override
public Context getContext(String contextType) {
  Context context = getCompositeNode().getDefaultContext(contextType);
  if (context != null) {
    return context;
  }
  return super.getContext(contextType);
}

@Override
public Context getContext(String contextId) {
  Context context = getDefaultContext(contextId);
  if (context != null) {
    return context;
  }
  return super.getContext(contextId);
}

public boolean acceptsEvent(String type, Object event) {
  for (Node node: internalGetNodes()) {
    if (node instanceof EventNodeInterface) {
      if (((EventNodeInterface) node).acceptsEvent(type, event)) {
        return true;
      }
    }
  }
  return false;
}

public void addNode(Node node) {
  getCompositeNode().addNode(node);
}

public void linkIncomingConnections(String inType, long inNodeId, String inNodeType) {
  getCompositeNode().linkIncomingConnections(inType, inNodeId, inNodeType);
}

public void linkOutgoingConnections(long outNodeId, String outNodeType, String outType) {
  getCompositeNode().linkOutgoingConnections(outNodeId, outNodeType, outType);
}

@Override
public Context getContext(String contextType, long id) {
  Context ctx =  super.getContext(contextType, id);
  if (ctx == null) {
    ctx = getCompositeNode().getContext(contextType, id);        
  }
  
  return ctx;
}

@Override
public List<Context> getContexts(String contextType) {
  List<Context> contexts = super.getContexts(contextType);
  if (contexts == null) {
    contexts = getCompositeNode().getContexts(contextType);        
  }
  
  return contexts;
}

public void removeNode(Node node) {
  getCompositeNode().removeNode(node);
}

public CompositeNode.NodeAndType getLinkedIncomingNode(String inType) {
  return getCompositeNode().getLinkedIncomingNode(inType);
}

protected Map<String, CompositeNode.NodeAndType> getInPorts(CompositeNode compositeNode) {
  return ((ForEachNode) compositeNode).getCompositeNode().getLinkedIncomingNodes();
}

protected Map<String, CompositeNode.NodeAndType> getOutPorts(CompositeNode compositeNode) {
  return ((ForEachNode) compositeNode).getCompositeNode().getLinkedOutgoingNodes();
}

public CompositeNode.NodeAndType getLinkedOutgoingNode(String inType) {
  return getCompositeNode().getLinkedOutgoingNode(inType);
}

public void linkOutgoingConnections(long outNodeId, String outNodeType, String outType) {
  linkOutgoingConnections(new NodeAndType(this, outNodeId, outNodeType), outType);
}

public void linkIncomingConnections(String inType, long inNodeId, String inNodeType) {
  linkIncomingConnections(inType, new NodeAndType(nodeContainer, inNodeId, inNodeType));
}

public StartNode findStartNode() {
  for (Node node: getNodes()) {
    if (node instanceof StartNode) {
      StartNode startNode = (StartNode) node;                                    
      return startNode;                           
    }
  }
  return null;
}

@Override
public Context getContext(String contextId) {
  Context context = getDefaultContext(contextId);
  if (context != null) {
    return context;
  }
  return super.getContext(contextId);
}

  @Override
  public Context getContext(String contextId) {
    Context context = getDefaultContext(contextId);
    if (context != null) {
      return context;
    }
    return super.getContext(contextId);
  }
}

public Node internalGetNode(long id) {
  try {
    return getNode(id);
  } catch (IllegalArgumentException e) {
    return null;
  }
}

public EventTransformerImpl(Transformation transformation) {
  if (transformation != null) {
    this.transformation = transformation;
    this.name = transformation.getSource();
    
    if (this.name == null) {
      this.name = "event";
    }
  }
}