How to use

AstWriteConfigNode

in

org.kaazing.k3po.lang.internal.ast

@Override
public AstScriptNode visit(AstWriteConfigNode node, State state) {
  conditionallyInjectWriteBarrier(state, node.getRegionInfo());
  state.streamables.add(node);
  state.readWriteState = ReadWriteState.WRITE;
  return null;
}

public StreamNested(R builder) {
  super(new AstWriteConfigNode(), builder);
}

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

private static WriteConfigHandler newWriteHttpTrailerHandler(
  AstWriteConfigNode node,
  Function<AstValue<?>, MessageEncoder> encoderFactory)
{
  AstValue<?> name = node.getValue("name");
  MessageEncoder nameEncoder = encoderFactory.apply(name);
  List<MessageEncoder> valueEncoders = new ArrayList<>();
  for (AstValue<?> value : node.getValues()) {
    valueEncoders.add(encoderFactory.apply(value));
  }
  WriteConfigHandler handler = new WriteConfigHandler(new HttpTrailerEncoder(nameEncoder, valueEncoders));
  handler.setRegionInfo(node.getRegionInfo());
  return handler;
}

private static WriteConfigHandler newWriteHttpStatusHandler(
  AstWriteConfigNode node,
  Function<AstValue<?>, MessageEncoder> encoderFactory)
{
  AstValue<?> code = node.getValue("code");
  AstValue<?> reason = node.getValue("reason");
  MessageEncoder codeEncoder = encoderFactory.apply(code);
  MessageEncoder reasonEncoder = encoderFactory.apply(reason);
  WriteConfigHandler handler = new WriteConfigHandler(new HttpStatusEncoder(codeEncoder, reasonEncoder));
  handler.setRegionInfo(node.getRegionInfo());
  return handler;
}

  @Override
  public AstWriteConfigNode visitWriteValue(WriteValueContext ctx) {
    AstValueVisitor<?> visitor = new AstValueVisitor<>(factory, environment, Object.class);
    AstValue<?> value = visitor.visit(ctx);
    if (value != null) {
      if (namedFields.hasNext()) {
        TypeInfo<?> field = namedFields.next();
        node.setValue(field.getName(), value);
      }
      else if (anonymousFields > 0) {
        anonymousFields--;
        node.addValue(value);
      }
      else {
        throw new IllegalStateException(String.format("Unexpected %s syntax", node.getType()));
      }
      childInfos().add(value.getRegionInfo());
    }
    return node;
  }
}

@Override
public AstWriteConfigNode visitWriteConfigNode(WriteConfigNodeContext ctx) {
  String configQName = ctx.QualifiedName().getText();
  node = new AstWriteConfigNode();
  StructuredTypeInfo configType = TYPE_SYSTEM.writeConfig(configQName);
  namedFields = configType.getNamedFields().iterator();
  anonymousFields = configType.getAnonymousFields();
  node.setType(configType);
  super.visitWriteConfigNode(ctx);
  node.setRegionInfo(asSequentialRegion(childInfos, ctx));
  return node;
}

public ChannelHandler newWriteConfigHandler(
  AstWriteConfigNode node,
  Function<AstValue<?>, MessageEncoder> encoderFactory) {
  StructuredTypeInfo type = node.getType();
  WriteConfigFactory factory = writeConfigs.getOrDefault(type, (n, f) -> null);
  return factory.newHandler(node, encoderFactory);
}

public AstWriteConfigNodeBuilder setValue(String name, String value) {
  node.setValue(name, new AstLiteralTextValue(value));
  return this;
}

public AstWriteConfigNodeBuilder addValue(ValueExpression value, ExpressionContext environment) {
  node.addValue(new AstExpressionValue<>(value, environment));
  return this;
}

public StreamNested<R> setType(StructuredTypeInfo type) {
  node.setType(type);
  return this;
}

private static WriteConfigHandler newWriteHttpParameterHandler(
  AstWriteConfigNode node,
  Function<AstValue<?>, MessageEncoder> encoderFactory)
{
  AstValue<?> name = node.getValue("name");
  MessageEncoder nameEncoder = encoderFactory.apply(name);
  List<MessageEncoder> valueEncoders = new ArrayList<>();
  for (AstValue<?> value : node.getValues()) {
    valueEncoders.add(encoderFactory.apply(value));
  }
  WriteConfigHandler handler = new WriteConfigHandler(new HttpParameterEncoder(nameEncoder, valueEncoders));
  handler.setRegionInfo(node.getRegionInfo());
  return handler;
}

private static WriteConfigHandler newWriteHttpMethodHandler(
  AstWriteConfigNode node,
  Function<AstValue<?>, MessageEncoder> encoderFactory)
{
  AstValue<?> methodName = node.getValue();
  requireNonNull(methodName);
  MessageEncoder methodEncoder = encoderFactory.apply(methodName);
  WriteConfigHandler handler = new WriteConfigHandler(new HttpMethodEncoder(methodEncoder));
  handler.setRegionInfo(node.getRegionInfo());
  return handler;
}

@Override
public Configuration visit(AstWriteConfigNode node, State state) {
  Function<AstValue<?>, MessageEncoder> encoderFactory = v -> v.accept(new GenerateWriteEncoderVisitor(), null);
  ChannelHandler handler = behaviorSystem.newWriteConfigHandler(node, encoderFactory);
  if (handler != null) {
    Map<String, ChannelHandler> pipelineAsMap = state.pipelineAsMap;
    String handlerName = String.format("writeConfig#%d (%s)", pipelineAsMap.size() + 1, node.getType().getName());
    pipelineAsMap.put(handlerName, handler);
    return state.configuration;
  }
  else {
    throw new IllegalStateException("Unrecognized configuration type: " + node.getType());
  }
}

public StreamNested<R> setValue(String name, String value) {
  node.setValue(name, new AstLiteralTextValue(value));
  return this;
}

public StreamNested<R> addValue(String value) {
  node.addValue(new AstLiteralTextValue(value));
  return this;
}

public AstWriteConfigNodeBuilder setType(StructuredTypeInfo type) {
  node.setType(type);
  return this;
}

private static WriteConfigHandler newWriteHttpHeaderHandler(
  AstWriteConfigNode node,
  Function<AstValue<?>, MessageEncoder> encoderFactory)
{
  AstValue<?> name = node.getValue("name");
  MessageEncoder nameEncoder = encoderFactory.apply(name);
  List<MessageEncoder> valueEncoders = new ArrayList<>();
  for (AstValue<?> value : node.getValues()) {
    valueEncoders.add(encoderFactory.apply(value));
  }
  WriteConfigHandler handler = new WriteConfigHandler(new HttpHeaderEncoder(nameEncoder, valueEncoders));
  handler.setRegionInfo(node.getRegionInfo());
  return handler;
}

private static WriteConfigHandler newWriteHttpVersionHandler(
  AstWriteConfigNode node,
  Function<AstValue<?>, MessageEncoder> encoderFactory)
{
  AstValue<?> version = node.getValue();
  MessageEncoder versionEncoder = encoderFactory.apply(version);
  WriteConfigHandler handler = new WriteConfigHandler(new HttpVersionEncoder(versionEncoder));
  handler.setRegionInfo(node.getRegionInfo());
  return handler;
}

@Override
public AstWriteConfigNode visitWriteConfigNode(WriteConfigNodeContext ctx) {
  AstWriteConfigNodeVisitor visitor = new AstWriteConfigNodeVisitor(factory, environment);
  AstWriteConfigNode writeConfigNode = visitor.visitWriteConfigNode(ctx);
  if (writeConfigNode != null) {
    childInfos().add(writeConfigNode.getRegionInfo());
  }
  return writeConfigNode;
}