How to use org.kaazing.k3po.lang.internal.ast

Best Java code snippets using org.kaazing.k3po.lang.internal.ast (Showing top 20 results out of 315)

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 ScheduledThreadPoolExecutor s =new ScheduledThreadPoolExecutor(corePoolSize)
ThreadFactory threadFactory;new ScheduledThreadPoolExecutor(corePoolSize, threadFactory)
String str;new ScheduledThreadPoolExecutor(1, new ThreadFactoryBuilder().setNameFormat(str).build())
Smart code suggestions by Tabnine
}

@Override
public AstScriptNode visit(AstAcceptNode acceptNode, State state) {
  for (AstStreamableNode streamable : acceptNode.getStreamables()) {
    streamable.accept(this, state);
  }
  for (AstAcceptableNode acceptable : acceptNode.getAcceptables()) {
    state.readState = StreamState.OPEN;
    state.writeState = StreamState.OPEN;
    acceptable.accept(this, state);
  }
  return null;
}

@Override
public AstScriptNode visit(AstScriptNode script, State state) {
  for (AstStreamNode stream : script.getStreams()) {
    stream.accept(this, state);
  }
  return null;
}

@Override
protected void describe(StringBuilder buf) {
  describeLine(buf);
  if (streamables != null) {
    for (AstRegion streamable : streamables) {
      streamable.describe(buf);
    }
  }
}

@Override
public Configuration visit(AstScriptNode script, State state) {
  state.configuration = new Configuration();
  for (AstPropertyNode property : script.getProperties()) {
    property.accept(this, state);
  }
  for (AstStreamNode stream : script.getStreams()) {
    stream.accept(this, state);
  }
  return state.configuration;
}

@Override
public AstDisconnectedNode visitDisconnectedNode(DisconnectedNodeContext ctx) {
  node = new AstDisconnectedNode();
  node.setRegionInfo(asSequentialRegion(childInfos, ctx));
  return node;
}

@Override
public AstScriptNode visit(AstConnectNode connectNode, State state) {
  state.writeState = StreamState.OPEN;
  state.readState = StreamState.OPEN;
  for (AstStreamableNode streamable : connectNode.getStreamables()) {
    streamable.accept(this, state);
  }
  return null;
}

@Override
public AstScriptNode visit(AstAcceptableNode acceptableNode, State state) {
  for (AstStreamableNode streamable : acceptableNode.getStreamables()) {
    streamable.accept(this, state);
  }
  return null;
}

@Override
protected void describe(StringBuilder buf) {
  super.describe(buf);
  if (acceptables != null) {
    for (AstAcceptableNode acceptable : acceptables) {
      acceptable.describe(buf);
    }
  }
}

@Override
public AstClosedNode visitClosedNode(ClosedNodeContext ctx) {
  node = new AstClosedNode();
  node.setRegionInfo(asSequentialRegion(childInfos, ctx));
  return node;
}

@Override
public AstConnectedNode visitConnectedNode(ConnectedNodeContext ctx) {
  node = new AstConnectedNode();
  node.setRegionInfo(asSequentialRegion(childInfos, ctx));
  return node;
}

@Override
public AstWriteCloseNode visitWriteCloseNode(WriteCloseNodeContext ctx) {
  node = new AstWriteCloseNode();
  node.setRegionInfo(asSequentialRegion(childInfos, ctx));
  return node;
}

@Override
public AstUnbindNode visitUnbindNode(UnbindNodeContext ctx) {
  node = new AstUnbindNode();
  node.setRegionInfo(asSequentialRegion(childInfos, ctx));
  return node;
}

@Override
public AstChildClosedNode visitChildClosedNode(ChildClosedNodeContext ctx) {
  node = new AstChildClosedNode();
  node.setRegionInfo(asSequentialRegion(childInfos, ctx));
  return node;
}

@Override
public <R, P> R accept(Visitor<R, P> visitor, P parameter) {
  return visitor.visit(this, parameter);
}
@Override

@Override
protected final boolean equalTo(AstOptionNode that) {
  return that instanceof AstWriteOptionNode &&
      equalTo((AstWriteOptionNode) that);
}

@Override
protected final boolean equalTo(AstOptionNode that) {
  return that instanceof AstReadOptionNode &&
      equalTo((AstReadOptionNode) that);
}

@Override
protected final boolean equalTo(AstRegion that) {
  return that instanceof AstOptionNode &&
      equalTo((AstOptionNode) that);
}

@Override
public <R, P> R accept(Visitor<R, P> visitor, P parameter) {
  return visitor.visit(this, parameter);
}
@Override

@Override
public <R, P> R accept(Visitor<R, P> visitor, P parameter) {
  return visitor.visit(this, parameter);
}
@Override

@Override
public <R, P> R accept(Visitor<R, P> visitor, P parameter) {
  return visitor.visit(this, parameter);
}
@Override